清云青云
清云青云

JAVA 23种设计模式示例

目录

一.单例模式

二.工厂方法模式

三.抽象工厂模式

四.建造者模式

五.原型模式

六.享元模式

七.门面模式

八.适配器模式

九.装饰者模式

十.策略模式

十一.模板方法模式

十二.观察者模式

十三.责任链模式

十四.代理模式

十五.桥接模式

十六.组合模式

十七.命令模式

十八.状态模式

十九.中介者模式

二十.迭代器模式

二十一.访问者模式

二十二.备忘录模式

二十三.解释器模式

JAVA 23种设计模式示例_第1张图片

一.单例模式

某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例。

1.懒汉模式：延时加载，只有在真正使用到的时候，才进行实例化。

public class LazySingleton {
	
	private volatile static LazySingleton instance = null;
	
	private LazySingleton() {
		
	}
	
	public static LazySingleton getInstance() {
		if(null == instance) {
			synchronized (LazySingleton.class) {
				if(null == instance) {
					instance = new LazySingleton();
				}
			}
		}
		return instance;
	}
	
}

（1）线程安全问题

（2）double check加锁优化

（3）编译器（JIT），CPU对满足as-if-series的指令会进行指令重排，会导致获取到未初始化的实例，所以需要加上volatile关键字进行修饰，防止指令重排（创建一个对象，需要经过开辟空间、赋默认值、初始化的过程）。

2.饿汉模式：

只有在真正主动使用对应的类时，才会触发初始化，例如（当前类时启动类即main函数所在类，直接进行new操作，访问静态属性、访问静态方法，用反射访问类等）；类加载的初始化阶段就完成了实例的初始化，本质上就是借助于jvm类加载机制，保证实例的唯一性（初始化过程只会执行一次）及线程安全（JVM以同步的形式来完成类加载的整个过程）。

类加载过程：

（1）加载二进制数据到内存中，生成对应的class数据结构

（2）连接：a.验证，b.准备（给类的静态成员变量赋默认值），c.解析

（2）初始化：给类的静态变量赋初值

public class HungrySingleton {

	public static String name = "qingyun";
	private static HungrySingleton instance = new HungrySingleton();

	
	private HungrySingleton() {
		
	}
	
	public static HungrySingleton getInstance() {
		return instance;
	}
	
}

使用静态内部类实现饿汉模式：

public class InnerClassSingleton {
	
	public static String name= "qingyun";
	
	private InnerClassSingleton() {
		
	}
	
	private static class SingletonHolder{
		private static InnerClassSingleton instance = new InnerClassSingleton();
	}
	
	public static InnerClassSingleton getInstance() {
		return SingletonHolder.instance;
	}
	
}

当访问静态name属性时，不会加载instance的初始化，只有真正使用到对应的类时，才会初始化，例如调用InnerClassSingleton.getInstance()。

要想反编译查看类加载的过程，可以通过idea的Terminal查看，进入class所在的目录，执行javap命令：

JAVA 23种设计模式示例_第2张图片

3.使用序列化、反序列化的方式创建单例，需要保证类的唯一性。

（1）把类序列化

类需要实现Serializable接口，并且需要设置serialVersionUID 的值，使用jdk自带的ObjectOutputStream把类序列化到磁盘上。

public class LazySingletonMain {

    public static void main(String[] args) {
        try {
            //获取实体
            LazySingleton instance = LazySingleton.getInstance();
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("name"));
            oos.writeObject(instance);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class LazySingleton implements Serializable {
    private static final long serialVersionUID = 1L;

    private volatile static LazySingleton instance = null;

    private LazySingleton() {

    }

    public static LazySingleton getInstance() {
        if(null == instance) {
            synchronized (LazySingleton.class) {
                if(null == instance) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

执行完后会生产序列化的文件

JAVA 23种设计模式示例_第3张图片

 （2）把类反序列化，保证是单例的

使用jdk自带的ObjectInputStream把序列化的类反序列化，这样使用序列化的方式进行单例创建才能保证唯一性。

public class LazySingletonMain {

    public static void main(String[] args) {
        try {
            LazySingleton instance = LazySingleton.getInstance();
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("name"));
            //反序列化实体
            LazySingleton lazySingleton = (LazySingleton)ois.readObject();
            System.out.println(lazySingleton == instance);  //输出true
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class LazySingleton implements Serializable {
    //需要制定版本，才能在序列化和反序列化中匹配为同一个实体
    private static final long serialVersionUID = 1L;

    private volatile static LazySingleton instance = null;

    private LazySingleton() {

    }

    public static LazySingleton getInstance() {
        if(null == instance) {
            synchronized (LazySingleton.class) {
                if(null == instance) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }

    //反序列化的时候，生成实体时执行此处代码
    private Object readResolve() throws ObjectStreamException {
        return getInstance();
    }
}

二.工厂方法模式

Factory Method 定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法模式使得一个类的实例化延时到子类。

应用场景：

1.当你不知道该使用对象的确切类型的时候；

2.当你希望为库或框架提供扩展其它内部组件的方法时。

主要优点：

1.将具体产品和创建者解耦；

2.符合单一职责原则；

3.符合开闭原则。

public class FactoryMethod {

    public static void main(String[] args) {
        //创建子类，使用继承的父类来接收
        //Application application = new CreateProductA();
        Application application = new CreateProductB();
        //使用接口类来接收创建出来类，体现了多态
        Product productObject = application.getProduct();
        //创建的是哪个类，调用到的就是哪个类的方法实现
        productObject.method();
    }
}

//定义一个接口类
interface Product{
    public void method();
}

//类实现了接口，必须实现接口中的方法
class ProductA implements Product{
    @Override
    public void method() {
        System.out.println("ProductA method");
    }
}


class ProductB implements Product{
    @Override
    public void method() {
        System.out.println("ProductB method");
    }
}

//抽象类里面不一定要有抽象方法；有抽象方法，类必须要是抽象类
abstract class Application {
    //工厂方法类，返回的是一个接口类
    abstract Product getProduct();
}

//子类继承了抽象类，子类必须实现抽象类里的方法
class CreateProductA extends Application{
    @Override
    Product getProduct() {
        //ProductA实现了Product接口，所以可以把创建的ProductA用Product接收
        return new ProductA();
    }
}

//子类继承了抽象类，子类必须实现抽象类里的方法
class CreateProductB extends Application{
    @Override
    Product getProduct() {
        return new ProductB();
    }
}

三.抽象工厂模式

Abstract Factory提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

应用场景：

程序需要处理不同序列的相关产品，但是你不希望它依赖于这些产品的具体类时，可是使用抽象工厂。

优点：

1.可以确信你从工厂得到的产品彼此是兼容的；

2.可以避免具体产品和客户端代码之间的紧密耦合；

3.符合单一职责原则；

4.符合开闭原则。

public class AbstractFactory {
    public static void main(String[] args) {
        //创建一个类，使用其实现的接口来接收
        IDataBaseUtils iDataBaseUtils = new MysqlDataBaseUtils();
        IConnection iConnection = iDataBaseUtils.getConnection();
        iConnection.connection();
        ICommand iCommand = iDataBaseUtils.getCommand();
        iCommand.command();
    }
}

interface IConnection{
    void connection();
}

interface ICommand{
    void command();
}

interface IDataBaseUtils{
    //包含一组的工厂方法
    IConnection getConnection();
    ICommand getCommand();
}

class MysqlConnection implements IConnection{
    @Override
    public void connection() {
        System.out.println("mysql connection");
    }
}

class OracleConnection implements IConnection{
    @Override
    public void connection() {
        System.out.println("oracle connection");
    }
}

class MysqlCommand implements ICommand{
    @Override
    public void command() {
        System.out.println("mysql command");
    }
}

class OracleCommand implements ICommand{
    @Override
    public void command() {
        System.out.println("oracle command");
    }
}

class MysqlDataBaseUtils implements IDataBaseUtils{
    @Override
    public IConnection getConnection() {
        return new MysqlConnection();
    }
    @Override
    public ICommand getCommand() {
        return new MysqlCommand();
    }
}

class OracleDataBaseUtils implements IDataBaseUtils{
    @Override
    public IConnection getConnection() {
        return new OracleConnection();
    }
    @Override
    public ICommand getCommand() {
        return new OracleCommand();
    }
}

四.建造者模式

将一个复杂对象的创建与他的标识分离，使得同样的构建过程可以创建不同的表示

应用场景：

1.需要生成的对象具有复杂的内部结构；

2.需要生成的对象内部属性本身相互依赖；

3.与不可变对象配合使用。

优点：

1.建造者独立，易扩展；

2.便于控制细节风险。

spring源码中的使用：

1.org.springframework.web.servlet.mvc.method.RequestMappingInfo;

2.org.springframework.beans.factory.support.BeanDefinitionBuilder;

public class BuilderTest {

    public static void main(String[] args) {
        ProductBulider productBulider = new DefaultCreateBuilderProduct();
        Director director = new Director(productBulider);
        Product product = director.makeProduct("xxx", "1", "2", "3");
        System.out.println(product.toString());
    }
}

interface ProductBulider{
    void buliderProductName(String productName);
    void buliderPart1(String part1);
    void buliderPart2(String part2);
    void buliderPart3(String part3);
    Product bulid();
}

class Director{
    private ProductBulider productBulider;

    public Director(ProductBulider productBulider){
        this.productBulider = productBulider;
    }

    public Product makeProduct(String productName, String part1, String part2, String part3){
        productBulider.buliderProductName(productName);
        productBulider.buliderPart1(part1);
        productBulider.buliderPart2(part2);
        productBulider.buliderPart3(part3);
        Product product = productBulider.bulid();
        return product;
    }
}

class DefaultCreateBuilderProduct implements ProductBulider{
    private String productName;
    private String part1;
    private String part2;
    private String part3;

    @Override
    public void buliderProductName(String productName) {
        this.productName = productName;
    }

    @Override
    public void buliderPart1(String part1) {
        this.part1 = part1;
    }

    @Override
    public void buliderPart2(String part2) {
        this.part2 = part2;
    }

    @Override
    public void buliderPart3(String part3) {
        this.part3 = part3;
    }

    @Override
    public Product bulid() {
        return new Product( this.productName,  this.part1,  this.part2,  this.part3);
    }
}

class Product{
    private String productName;
    private String part1;
    private String part2;
    private String part3;

    public Product(){

    }

    public Product(String productName, String part1, String part2, String part3) {
        this.productName = productName;
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    public String getPart1() {
        return part1;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public String getPart2() {
        return part2;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    public String getPart3() {
        return part3;
    }

    public void setPart3(String part3) {
        this.part3 = part3;
    }

    @Override
    public String toString() {
        return "Product{" +
                "productName='" + productName + '\'' +
                ", part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3='" + part3 + '\'' +
                '}';
    }
}

简化版的构造模式（内部静态类）

public class BuilderTest {

    public static void main(String[] args) {
        Product product = new Product.ProductBuilder().productName("xxx").part1("1").part2("2").part3("3").bulid();
        System.out.println(product.toString());
    }
}


class Product{
    private final String productName;
    private final String part1;
    private final String part2;
    private final String part3;

    static class ProductBuilder{
        private  String productName;
        private  String part1;
        private  String part2;
        private  String part3;

        public ProductBuilder productName(String productName){
            this.productName = productName;
            return this;
        }

        public ProductBuilder part1(String part1){
            this.part1 = part1;
            return this;
        }

        public ProductBuilder part2(String part2){
            this.part2 = part2;
            return this;
        }

        public ProductBuilder part3(String part3){
            this.part3 = part3;
            return this;
        }

        Product bulid(){
            return new Product(this.productName,this.part1,this.part2,this.part3);
        }
    }

    public Product(String productName, String part1, String part2, String part3) {
        this.productName = productName;
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
    }

    @Override
    public String toString() {
        return "Product{" +
                "productName='" + productName + '\'' +
                ", part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3='" + part3 + '\'' +
                '}';
    }
}

五.原型模式

原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

应用场景：

当代码不需要依赖于需要复制的对象的具体类时，请使用Prototype模式。

优点：

1.可以不耦合具体类的情况下克隆对象；

2.避免重复的初始化代码；

3.更方便的构建复杂对象。

Spring源码中的应用：

1.org.springframework.beans.factory.support.AbstractBeanDefinition

2.java.util.Arrays

public class PrototypeTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        BaseInfo baseInfo = new BaseInfo("1111");
        Product product = new Product("xx商品","part1","part2","part3",baseInfo);
        System.out.println(product.toString());
        Product clone = product.clone();
        System.out.println(clone.toString());
    }

}

class BaseInfo implements Cloneable{
    private String productId;

    public BaseInfo(String productId){
        this.productId = productId;
    }

    @Override
    protected BaseInfo clone() throws CloneNotSupportedException{
        BaseInfo baseInfo = (BaseInfo)super.clone();
        return baseInfo;
    }

    @Override
    public String toString() {
        return super.hashCode()+" ] BaseInfo{" +
                "productId='" + productId + '\'' +
                '}';
    }
}

class Product implements Cloneable{
    private String productName;
    private String part1;
    private String part2;
    private String part3;
    private BaseInfo baseInfo;

    @Override
    protected Product clone() throws CloneNotSupportedException{
        Product product = (Product)super.clone();
        BaseInfo baseInfo = (BaseInfo)product.baseInfo.clone();
        product.setBaseInfo(baseInfo);
        return product;
    }

    public Product(String productName, String part1, String part2, String part3,BaseInfo baseInfo) {
        this.productName = productName;
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
        this.baseInfo = baseInfo;
    }

    @Override
    public String toString() {
        return super.hashCode()+"Product{" +
                "productName='" + productName + '\'' +
                ", part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                ", part3='" + part3 + '\'' +
                ", baseInfo=" + baseInfo +
                '}';
    }

    public BaseInfo getBaseInfo() {
        return baseInfo;
    }

    public void setBaseInfo(BaseInfo baseInfo) {
        this.baseInfo = baseInfo;
    }
}

对一个对象的拷贝我们使实体实现Cloneable接口，重写它的clone方法；若是实体里面引入了其它的实体，例如上面的Product类中引入了BaseInfo类，若是BaseInfo类没有实现Cloneable接口，重写它的clone方法，则对BaseInfo的拷贝是浅拷贝（类的hashcode相同）：

浅拷贝的问题时，修改其中一个的BaseInfo值时，另一个也会跟随着变化。

要达到深拷贝的程度，我们需要让引入的BaseInfo也实现Cloneable接口，重写它的clone方法，在Product类中调用clone方法时，调用下BaseInfo的clone来拷贝BaseInfo，此时是深拷贝（类的hashcode不相同）：

六.享元模式

     享元模式运用共享技术有效的支持大量细粒度的对象。

优点：

1.如果系统有大量类似的对象，可以节省大量的内存及CUP资源

Spring源码中的运用：

1.String、Integer、Long
2.com.sun.org.apache.bcel.internal.generic.InstructionConstants
public class FlyWeightTest {

    public static void main(String[] args) {
        //创建多个marker对象，里面的参数BaseMessage相同时使用共享的方式
        Marker marker1 = new Marker(new BigDecimal(10),new BigDecimal(30),BaseMessageFactory.getBaseMessage("xx","xxxtip"));
        Marker marker2 = new Marker(new BigDecimal(60),new BigDecimal(80),BaseMessageFactory.getBaseMessage("xx","xxxtip"));
        System.out.println(marker1.toString());
        System.out.println(marker2.toString());
    }
}

class Marker{
    private BigDecimal lat;
    private BigDecimal lon;
    private BaseMessage baseMessage;

    public Marker(BigDecimal lat, BigDecimal lon, BaseMessage baseMessage) {
        this.lat = lat;
        this.lon = lon;
        this.baseMessage = baseMessage;
    }

    @Override
    public String toString() {
        return "Marker{" +
                "lat=" + lat +
                ", lon=" + lon +
                ", baseMessage=" + baseMessage.toString() +
                '}';
    }
}

class BaseMessageFactory{
    //使用map存放已经创建的对象，供其他线程创建时复用
    private static Map map = new ConcurrentHashMap();
    public static BaseMessage getBaseMessage(String title,String tip){
        if(map.containsKey(title)){
            return map.get(title);
        }
        BaseMessage baseMessage = new BaseMessage(title,tip);
        map.put(title,baseMessage);
        return baseMessage;
    }
}


class BaseMessage{
    //字段使用final修饰，创建后不可改变值
    private final String title;
    private final String tip;

    BaseMessage(String title, String tip) {
        System.out.println("create BaseMessage:"+title);
        this.title = title;
        this.tip = tip;
    }

    @Override
    public String toString() {
        return "BaseMessage{" +
                "title='" + title + '\'' +
                ", tip='" + tip + '\'' +
                '}';
    }
}

七.门面模式

    门面模式为子系统中的一组接口提供一个一致的接口，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

JAVA 23种设计模式示例_第4张图片

 应用场景：

1.当需要使用复杂子系统的有限但直接的接口时，请使用Facade模式。

2.当您想要将子系统组织成层时，请使用Facade。

优点：

1.简化客户端的调用。

源码中的经典应用：

1.org.apache.catalina.connector.RequestFacade
public class FacadeTest {

    public static void main(String[] args) {
        Client1 client1 = new Client1();
        client1.pritlnSomething();
    }
}

//客户端1
class Client1{
    Facate facate = new Facate();

    public void pritlnSomething(){
        //使用门面模式来统一调用
        facate.printAll();
    }
}

//门面模式，有facate来统一调用需要调用的方法
class Facate{
    SubMessage1 subMessage1 = new SubMessage1();
    SubMessage2 subMessage2 = new SubMessage2();
    SubMessage3 subMessage3 = new SubMessage3();

    public void printAll(){
        subMessage1.printSub1();
        subMessage2.printSub2();
        subMessage3.printSub3();
    }
}

//子类
class SubMessage1{
    public void printSub1(){
        System.out.println("printSub1...");
    }
}

class SubMessage2{
    public void printSub2(){
        System.out.println("printSub2...");
    }
}

class SubMessage3{
    public void printSub3(){
        System.out.println("printSub3...");
    }
}

八.适配器模式

    适配器模式将一个类的接口转换成客户希望的另一个接口，Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

应用场景：

1.当你希望使用某些现有类，但其接口与你的其它代码不兼容时，请使用适配器类。

2.当你希望重用几个现有的子类，这些子类缺少一些不能添加到超类中的公共功能时，请使用该模式。

优点：

1.符合单一职责原则。

2.符合开闭原则。

JDK & Spring源码中的应用

JDK:
1.java.util.Arrays # asList()
2.java.util.Collections # list()
Spring:
1.org.springframework.context.event.GenericApplicationListenerAdapter
Object形式的适配器模式（注入类的方式）:
public class AdapterObject {

    public static void main(String[] args) {
        Target target = new Adapter(new Adaptee());
        System.out.println(target.adapter10v());
    }
}

interface Target{
    int adapter10v();
}

class Adapter implements Target{

    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public int adapter10v() {
        int i = adaptee.adapter220v();
        //经过处理，输出10V的电压
        int j = i/22;
        System.out.println(String.format("原电压  %d  v   转化后电压   %d  v",i,j));
        return j;
    }
}

//提供220V电压的类
class Adaptee{
    public int adapter220v(){
        return 220;
    }
}
Class形式的适配器模式（继承类的方式）：
public class AdapterClassDemo {

    public static void main(String[] args) {
        TargetClass targetClass = new AdapterClass();
        System.out.println(targetClass.adapter10v());
    }
}

interface TargetClass{
    int adapter10v();
}

//使用类继承的方式
class AdapterClass extends AdapteeClass implements TargetClass{

    @Override
    public int adapter10v() {
        int i = adapter220v();
        int j = i /22;
        System.out.println(String.format("原电压  %d  v   转化后电压   %d  v",i,j));
        return j;
    }
}


class AdapteeClass{
    public int adapter220v(){
        return 220;
    }
}

九.装饰者模式

      装饰者模式Decorator在不改变原有对象的基础上，将功能附加到对象上。

应用场景：

1.扩展一个类的功能或给一个类添加附加功能。

优点：

1.不改变原有对象的情况下，给一个对象扩展功能。

2.使用不同的组合可以实现不同的效果。

3.符合开闭原则（对扩展开放，对修改关闭）。

经典案例：

1.javax.servlet.http.HttpServletRequest
2.javax.servlet.http.HttpServletResponse
public class DecoratorTest {
    public static void main(String[] args) {
        //这是一开始既有的实现
        /*Component component = new CreateComponent();
        component.operation();*/
        //使用接口接收创建的类；创建具体类的实现作为它实现的接口，此接口是一个参数，即可在不改变原有对象的基础上，扩展附加一些属性
        Component component = new CreateDecorator2(new CreateDecoator1(new CreateComponent()));
        component.operation();
    }
}

interface Component{
    void operation();
}

class CreateComponent implements Component{
    @Override
    public void operation() {
        System.out.println("拍照");
    }
}

//抽象类实现接口，可以不实现接口中的方法，当子类继承此抽象类时再对接口中的方法进行实现
abstract class Decorator implements Component{
    Component component;

    public Decorator(Component component){
        this.component = component;
    }
}

//子类继承抽象父类，需要实现父类未实现的接口方法，需要调用父类的定义的构造函数
class CreateDecoator1 extends Decorator{

    //构造父类的构造方法
    public CreateDecoator1(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        System.out.println("美颜");
        //调用创建CreateDecoator1类时传递到父抽象类Decorator的component
        component.operation();
    }
}

class CreateDecorator2 extends Decorator{

    public CreateDecorator2(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        System.out.println("滤镜");
        component.operation();
    }
}

十.策略模式

     策略模式Stragety定义了算法族，分别封装起来，让它们直接可以互相替换，此模式的变化独立于算法的使用者。

应用场景：

1.业务代码需要根据场景不同，切换不同的实现逻辑。

2.代码中存在大量if - else判断。

优点：

1.符合开闭原则。

2.避免使用多重条件转移语句，例if - else 语句、switch语句。

3.可以提高算法的安全性和保密性。

经典案例：

1.java.util.Arrays # sort(T[] a, Comparator c)
2.org.springframework.beans.factory.support.InstantiationStrategy
public class StrategyTest {

    public static void main(String[] args) {
        Zombie zombie = new NormalZombie(new OneStepMove(),new OneAttack());
        zombie.display();
        zombie.move();
        zombie.attack();
        //根据传入的值，改变对应的方法调用输出的结果
        zombie.setMoveable(new TenStepMove());
        zombie.setAttackable(new TenAttack());
        System.out.println("......进过策略模式传递对象改变后，调用同样的方法输出结果......");
        zombie.move();
        zombie.attack();
    }
}

//移动的接口
interface Moveable{
    void move();
}
//攻击的接口
interface Attackable{
    void attack();
}

//定义一个抽象类
abstract class Zombie {
    abstract void display();
    Moveable moveable;
    Attackable attackable;
    abstract void move();
    abstract void attack();

    public Zombie(Moveable moveable, Attackable attackable) {
        this.moveable = moveable;
        this.attackable = attackable;
    }

    public void setMoveable(Moveable moveable) {
        this.moveable = moveable;
    }

    public void setAttackable(Attackable attackable) {
        this.attackable = attackable;
    }
}

//子类继承抽象类
class NormalZombie extends Zombie{

    public NormalZombie(Moveable moveable, Attackable attackable) {
        super(moveable, attackable);
    }

    @Override
    void display() {
        System.out.println("普通类");
    }

    @Override
    void move() {
        moveable.move();
    }

    @Override
    void attack() {
        attackable.attack();
    }
}

//子类继承抽象类
class StyleZombie extends Zombie{

    public StyleZombie(Moveable moveable, Attackable attackable) {
        super(moveable, attackable);
    }

    @Override
    void display() {
        System.out.println("风格类......");
    }

    @Override
    void move() {
        moveable.move();
    }

    @Override
    void attack() {
        attackable.attack();
    }
}

//定义类实现具体的移动方法
class OneStepMove implements Moveable{
    @Override
    public void move() {
        System.out.println("走一步");
    }
}

class TenStepMove implements Moveable{
    @Override
    public void move() {
        System.out.println("走十步");
    }
}

class OneAttack implements Attackable{
    @Override
    public void attack() {
        System.out.println("一次攻击");
    }
}

class TenAttack implements Attackable{
    @Override
    public void attack() {
        System.out.println("十次攻击");
    }
}

程序执行输出结果值：

JAVA 23种设计模式示例_第5张图片

十一.模板方法模式

      模板方法模式Template Method定义一个操作的算法骨架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构，即可重定义改算法的某些特定步骤。

应用场景：

1.一次性实现一个算法不变的部分，并将可变部分留给子类实现。

2.各个子类中，公共部分被提取出来，集中到一个公共的父类中，避免代码重复。

优点：

1.提高代码复用性：将相同部分代码，放到抽象的父类中；

2.提供扩展性：将不同的代码，放到不同的子类中，通过对子类的扩展，增加新的行为；

3.符合开闭原则：通过父类调用子类的操作，通过对子类的扩展来增加新的行为。

Servlet Api & Spring源码：

//service中定义了doGet/doPost等方法，具体的实现由子类进行
1.javax.servlet.http.HttpServlet #service()

//handleRequest中定义了ModelAndView返回值，具体的实现由子类进行
2.org.springframework.web.servlet.mvc.AbstractController #handleRequest()
public class TemplateTest {

    public static void main(String[] args) {
        AbstraceClass abstraceClass = new SubClass2();
        abstraceClass.operator();
    }
}

/**
 * 抽象父类
 */
abstract class AbstraceClass{
    //一般此方法是默认调用的方法
    public void operator(){
        System.out.println("准备");
        System.out.println("处理");
        //调用模板方法，此方法由子类实现
        templateMethod();
    }

    protected abstract void templateMethod();
}

class SubClass1 extends AbstraceClass{
    //重写父类定义的抽象方法
    @Override
    protected void templateMethod() {
        System.out.println("子类1实现的方法");
    }
}

class SubClass2 extends AbstraceClass{
    //重写父类定义的抽象方法
    @Override
    protected void templateMethod() {
        System.out.println("子类2实现的方法");
    }
}

十二.观察者模式

    观察者模式Observer定义了对象之间的一对多依赖，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，它的所有依赖者都会收到通知并更新。

应用场景：

1.当更改一个对象的状态可能需要更改其它对象，并且实际的对象集事先未知或动态更改时，请使用观察者模式。

优点：

1.符合开闭原则；

2.可以在运行时建立对象之间的关系。

JDK & Spring源码中的应用：

//定义了存放观察者的集合、添加、删除、通知观察者update的方法
1.java.util.Observable 

//定义了onApplicationEvent通知方法，消息的发布在ApplicationEventMulticaster中，由multicastEvent方法获取getApplicationListeners()注册的监听集合，遍历此集合调用通知方法
2.org.springframework.context.ApplicationListener
public class ObserverTest {
    public static void main(String[] args) {
        Subject subject = new Subject();
        Observer subClass1 = new SubClass1();
        Observer subClass2 = new SubClass2();
        //把观察者对象添加进依赖的对象里面
        subject.add(subClass1);
        subject.add(subClass2);
        subject.notityAll("数据有更新了...");
        System.out.println("...移出某个需要通知的对象后...");
        subject.remove(subClass1);
        subject.notityAll("数据再次更新了...");
    }
}

class Subject {
    List list = new ArrayList();

    //添加需要通知的对象
    public void add(Observer observer){
        if(!list.contains(observer)){
            list.add(observer);
        }
    }

    //移出需要通知的对象
    public void remove(Observer observer){
        list.remove(observer);
    }

    //有变动，通知所有的监听对象
    public void notityAll(Object object){
        for(int i = 0;i < list.size();i++){
            Observer observer = list.get(i);
            observer.notity(object);
        }
    }
}

interface Observer{
    void notity(Object object);
}

class SubClass1 implements Observer{
    @Override
    public void notity(Object object) {
        System.out.println("通知消息1："+object);
    }
}

class SubClass2 implements Observer{
    @Override
    public void notity(Object object) {
        System.out.println("通知消息2："+object);
    }
}

十三.责任链模式

     责任链模式Chain Of Responsibility 为请求创建了一个接收者对象的链。

应用场景：

1.一个请求的处理需要多个对象当中的一个或几个协作处理。

优点：

1.请求的发送者和接受者解耦；

2.可以控制执行顺序；

3.符合开闭原则和单一职责原则。

经典案例：

//doFilter方法里面有一个FilterChain责任链
1.javax.servlet.Filter #doFilter()
2.javax.servlet.FilterChain #doFilter()
//sentinel中进行流控、熔断的策略就是使用的责任链模式，使用8中插槽slot的方式判断是否达到某种限制，达到则抛出对应的异常，触发对应的控制
3.com.alibaba.csp.sentinel.CtSph #lookProcessChain()
public class ChainOfResponsibilityTest {
    public static void main(String[] args) {
        //通过构建者模式创建request
        Request request = new Request.RequestBuilder().isLogin(false).isEnter(false).bulid();
        //定义责任链，LoginHandler的next为EnterHandler，EnterHandler的next为null
        Handler handler = new LoginHandler(new EnterHandler(null));
        boolean process = handler.process(request);
        if(process){
            System.out.println("校验通过");
        } else {
            System.out.println("校验不通过");
        }
    }
}

//定义一个请求类
class Request {
    private boolean isLogin;
    private boolean isEnter;

    public Request(boolean isLogin, boolean isEnter) {
        this.isLogin = isLogin;
        this.isEnter = isEnter;
    }

    //使用建造者模式创建
    static class RequestBuilder{
        private boolean isLogin;
        private boolean isEnter;

        RequestBuilder isLogin(boolean isLogin){
            this.isLogin = isLogin;
            return this;
        }
        
        RequestBuilder isEnter(boolean isEnter){
            this.isEnter = isEnter;
            return this;
        }
        
        Request bulid(){
            Request request = new Request(isLogin,isEnter);
            return request;
        }
    }

    public boolean isLogin() {
        return isLogin;
    }

    public boolean isEnter() {
        return isEnter;
    }
}

//定义一个抽象父类
abstract class Handler{
    Handler next;
    abstract boolean process(Request request);

    public Handler(Handler next) {
        this.next = next;
    }

    public Handler getNext() {
        return next;
    }

    public void setNext(Handler next) {
        this.next = next;
    }
}

//定义子类
class LoginHandler extends Handler{

    //定义next的值
    public LoginHandler(Handler next) {
        super(next);
    }

    @Override
    boolean process(Request request) {
        System.out.println("登陆校验");
        if(request.isLogin()){
            Handler next = getNext();
            if(null == next){
                return true;
            }
            if(next.process(request)){
                return true;
            }
        }
        return false;
    }
}

//定义子类
class EnterHandler extends Handler{

    public EnterHandler(Handler next) {
        super(next);
    }

    @Override
    boolean process(Request request) {
        System.out.println("进入处理");
        if(request.isEnter()){
            Handler next = getNext();
            if(null == next){
                return true;
            }
            if(next.process(request)){
                return true;
            }
        }
        return false;
    }
}

十四.代理模式

    代理模式proxy代理对象具备真实对象的功能，并代替真实对象完成相应操作，并能够在操作执行前后，对操作进行增强处理。

应用场景：

1.日志的采集；

2.实现aop；

3.Rpc远程接口调用。

优点：

1.在不修改目标对象的前提下，能通过代理对象对目标对象进行扩

①静态代理

     需要定义接口或者父类，代理对象和被代理对象需要实现相同的接口或者继承相同的父类，在代理对象中注入被代理类，通过代理对象调用真实的对象。

案例：

public class StaticProxyTest {
    public static void main(String[] args) {
       RentHouse rentHouse = new ProxyRent(new RealRent());
       rentHouse.rent();
    }
}

//定义一个接口类
interface RentHouse{
    void rent();
}

//定义一个真实类
class RealRent implements RentHouse{
    @Override
    public void rent() {
        System.out.println("房东租房");
    }
}

//定义一个代理类，代理类和真实类需要实现相同的接口
class ProxyRent implements RentHouse{
    //代理类需要注入真实的被代理类
    private RealRent realRent;
    public ProxyRent(RealRent realRent) {
        this.realRent = realRent;
    }

    @Override
    public void rent() {
        //在调用被代理类之前代理类可以添加一些其他的步骤
        System.out.println("带客户看房");
        //调用被代理类的方法
        realRent.rent();
        //在调用被代理类之后代理类可以添加一些其他的步骤
        System.out.println("签订合同");
    }
}

②jdk动态代理

      jdk动态代理涉及到java.lang.reflect.InvocationHandler和Proxy类，实现InvocationHandler接口后，重写invoke执行代理类的方法；使用Proxy的newProxyInstanse创建代理类，需要的参数为接口类，所以jdk动态代理需要使用接口类来接收，源码方法如下：

  //jdk创建代理类需要使用interfaces接口作为参数
  public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h)

案例：

public class JdkDynamicProxyTest {
    public static void main(String[] args) {
        //jdk1.8及之前的版本，设置保持jdk代理文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        //jkd1.8之后的版本，设置保持jdk代理文件
        //System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");
        JdkDynamicProxy proxy = new JdkDynamicProxy(new Cat("小猫"));
        Animal animal = (Animal) Proxy.newProxyInstance(proxy.getClass().getClassLoader(),new Class[]{Animal.class},proxy);
        animal.getUp();
        animal.sleep();

        proxy = new JdkDynamicProxy(new Student("学生"));
        Person person = (Person) Proxy.newProxyInstance(proxy.getClass().getClassLoader(),new Class[]{Person.class},proxy);
        person.getUp();
        person.sleep();
    }
}

//定义一个动物的接口
interface Animal{
    //起床的方法
    void getUp();
    //睡觉的方法
    void sleep();
}

//定义一个人的接口
interface Person{
    //起床的方法
    void getUp();
    //睡觉的方法
    void sleep();
}

//定义类实现接口
class Cat implements Animal{
    private String name;

    public Cat(String name) {
        this.name = name;
    }

    @Override
    public void getUp() {
        System.out.println("动物"+name+"起床");
    }

    @Override
    public void sleep() {
        System.out.println("动物"+name+"睡觉");
    }
}

//定义接口实现类
class Student implements Person{

    private String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public void getUp() {
        System.out.println("人类"+name+"起床");
    }

    @Override
    public void sleep() {
        System.out.println("人类"+name+"睡觉");
    }
}

//jdk动态代理，通过实现InvocationHandler，重写invoke方法
class JdkDynamicProxy implements InvocationHandler {
    //需要注入需要代理的类
    private Object bean;

    public JdkDynamicProxy(Object bean) {
        this.bean = bean;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //再调用代理类之前做一些前置处理
        String name = method.getName();
        if("getUp".equals(name)){
            System.out.println("早上好");
        } else if("sleep".equals(name)){
            System.out.println("晚安");
        }
        //执行被代理类的方法
        return method.invoke(bean,args);
    }


}

    可以通过System.getProperties().put来设置生成代理类的class文件，可以在invoke调用真实类之前附加一些处理，需要使用接口来接收代理类，生成的代理类继承自Proxy，实现的接口为创建代理类时传入的接口类，里面有接口类定义的方法。

JAVA 23种设计模式示例_第6张图片

 ③Cglib动态代理

      Cglib是一个机遇ASM字节码生成库，它允许在运行时对字节码进行修改和动态生成，cglib生成的是真实类的子类。主要使用到org.springframework.cglib.proxy.MethodInterceptor和Enhancer类，代理类实现MethodInterceptor接口，重写invoke调用代理类的方法，使用Enhancer字节码增强器来创界代理类。

案例：

public class CglibDynamicProxyTest {
    public static void main(String[] args) {
        //输出生成的代理类
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\aop");
        CglibDynamicPorxy cglibDynamicPorxy = new CglibDynamicPorxy(new CatCglib("小猫"));
        CatCglib catCglib = (CatCglib) cglibDynamicPorxy.getProxy();
        catCglib.getUp();
        catCglib.sleep();

        cglibDynamicPorxy = new CglibDynamicPorxy(new StudentCglib("学生"));
        StudentCglib studentCglib = (StudentCglib) cglibDynamicPorxy.getProxy();
        studentCglib.getUp();
        studentCglib.sleep();
    }
}

//创建代理类
class CglibDynamicPorxy implements MethodInterceptor {
    //注入需要代理的类
    Object bean;

    public CglibDynamicPorxy(Object bean) {
        this.bean = bean;
    }

    //字节码增强器，为无接口的类创建代理
    private Enhancer enhancer = new Enhancer();

    public Object getProxy(){
        //设置父类
        enhancer.setSuperclass(bean.getClass());
        //设置方法的回调
        enhancer.setCallback(this);
        //创建代理-子类，继承自父类
        return enhancer.create();
    }


    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        String name = method.getName();
        if("getUp".equals(name)){
            System.out.println("早上好");
        } else if("sleep".equals(name)){
            System.out.println("晚上好");
        }
        return method.invoke(bean,objects);
    }
}


//定义类实现接口
class CatCglib {
    private String name;

    public CatCglib() {
    }

    public CatCglib(String name) {
        this.name = name;
    }
    public void getUp() {
        System.out.println("动物"+name+"起床");
    }
    public void sleep() {
        System.out.println("动物"+name+"睡觉");
    }
}

//定义类
class StudentCglib{
    private String name;

    public StudentCglib() {
    }

    public StudentCglib(String name) {
        this.name = name;
    }
    public void getUp() {
        System.out.println("人类"+name+"起床");
    }
    public void sleep() {
        System.out.println("人类"+name+"睡觉");
    }
}

    可以通过System.setProperty来设置生成代理类的class文件地址，可以在invoke调用真实类之前附加一些处理，需要使用类来接收代理类，生成的代理类继承自真实类，实现的接口为Factory，里面有类定义的方法，相当于把真实类clone克隆了一份作为代理子类，代理类中有clone方法。

JAVA 23种设计模式示例_第7张图片

十五.桥接模式

     桥接模式Bridge将抽象和实现分离，使它们可以独立变化，它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。

应用场景：

1.当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时；

2.当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时；

3.当一个系统需要在构建的抽象化角色和具体化角色之间增加更多的灵活性时。

优点：

1.抽象和实现分离，扩展能力强；

2.符合开闭原则；

3.符合合成复用原则。

public class BridgeTest {
    public static void main(String[] args) {
        //创建实现化角色
        Animal animal = new Cat();
        //实现化角色，通过创建抽象子类时，注入进去；通过创建的子类进行桥接，使其可以调用到实现化角色
        Behavior behavior = new SubBehavior1(animal);
        behavior.wakeUp();
        //也可以使用其他组合
        behavior = new SubBehavior2(new Sheep());
        behavior.wakeUp();
    }
}

//定义接口-实现化角色
interface Animal{
    void operation();
}

//具体实现化角色
class Cat implements Animal{
    @Override
    public void operation() {
        System.out.println("小猫...");
    }
}

//具体实现化角色
class Sheep implements Animal{
    @Override
    public void operation() {
        System.out.println("山羊");
    }
}

//定义抽象化角色
abstract class Behavior{
    //注入实现化角色
    Animal animal;

    public Behavior(Animal animal) {
        this.animal = animal;
    }

    abstract public void wakeUp();
}

//扩展抽象化角色--桥接
class SubBehavior1 extends Behavior{
    public SubBehavior1(Animal animal) {
        super(animal);
    }

    @Override
    public void wakeUp() {
        System.out.println("扩展抽象化1调用：wakeUp");
        animal.operation();
    }
}

//扩展抽象化角色--桥接
class SubBehavior2 extends Behavior{
    public SubBehavior2(Animal animal) {
        super(animal);
    }

    @Override
    public void wakeUp() {
        System.out.println("扩展抽象化2调用：wakeUp");
        animal.operation();
    }
}

十六.组合模式

     组合模式Composite有时候又叫做整体-部分模式，它是一种将对象组合成树状的层次结构模式，用来表示整体-部分的关系，是用户对单个对象和组合对象有一致的访问性，属于结构形设计模式。它将对象组织到树形结构中，顶层的节点被称为根节点，根节点下面可以包含树枝节点和叶子节点，树枝节点下面又可以包含树枝节点和叶子节点，树形结构图如下：

JAVA 23种设计模式示例_第8张图片

应用场景：

1.在需要表示一个对象整体与部分的层次结构的场合；

2.要求对用户隐藏组合对象与单个对象的不同，用户可以用统一的接口使用组合结构中的所有对象的场合。

优点：

1.组合模式使得客户端代码可以一致的处理当个对象和组合对象，无须关心自己处理的是单个对象还是组合对象，简化了客户端代码；

2.更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而改变源代码，满足开闭原则。

①透明方式

      在该方式中，由于抽象构件声明了所有子类中的方法，所以客户端无须区别树叶对象和树枝对象，对客户端来说是透明的。但其缺点是：树叶构件中没有add（）、remove（）、getChild（）方法，却要实现他们（空实现或抛异常），这样会带来一些安全性问题。

例如使用组合模式组织这样的数型图：

JAVA 23种设计模式示例_第9张图片

public class TransparentCompositeTest {
    public static void main(String[] args) {
        Component composite0 = new Composite();
        Component composite1 = new Composite();
        Component left1 = new Leaf("1");
        Component left2 = new Leaf("2");
        Component left3 = new Leaf("3");
        composite0.add(left1);
        composite0.add(composite1);
        composite1.add(left2);
        composite1.add(left3);
        composite0.operate();
    }
}

//抽象构件-定义子类需要的所有方法
interface Component{
    void add(Component component);
    void remove(Component component);
    Component getChild(int index);
    void operate();
}

//树叶构件-没有添加、删除、获取子类的方法实现
class Leaf implements Component{

    private String name;

    public Leaf(String name) {
        this.name = name;
    }

    @Override
    public void add(Component component) {

    }

    @Override
    public void remove(Component component) {

    }

    @Override
    public Component getChild(int index) {
       return null;
    }

    @Override
    public void operate() {
        System.out.println("叶子："+name+"被访问");
    }
}

//树枝构件-包含它下面的子类集合
class Composite implements Component{

    private List childList = new ArrayList();

    @Override
    public void add(Component component) {
        childList.add(component);
    }

    @Override
    public void remove(Component component) {
       childList.remove(component);
    }

    @Override
    public Component getChild(int index) {
       return childList.get(index);
    }

    @Override
    public void operate() {
        for(Component component : childList){
            component.operate();
        }
    }
}

 ②安全方式

       在该方式中，将管理子构件的方法放到树枝构件中，抽象构件和树叶构件没有对子对象的管理方法，这样就避免了透明方式的安全性问题，但由于叶子和树枝有不同的接口，客户端在调用时要知道树叶对象和树枝对象的存在，所以失去了透明性。

public class SafeCompositeTest {
    public static void main(String[] args) {
        CompositeSafe compositeSafe0 = new CompositeSafe();
        CompositeSafe compositeSafe1 = new CompositeSafe();
        ComponentSafe leaf1 = new LeafSafe("1");
        ComponentSafe leaf2 = new LeafSafe("2");
        ComponentSafe leaf3 = new LeafSafe("3");
        compositeSafe0.add(leaf1);
        compositeSafe0.add(compositeSafe1);
        compositeSafe1.add(leaf2);
        compositeSafe1.add(leaf3);
        compositeSafe0.operate();
    }
}

//抽象构件-只定义公共的方法
interface ComponentSafe{
    void operate();
}

//树叶构件
class LeafSafe implements ComponentSafe{
    private String name;

    public LeafSafe(String name) {
        this.name = name;
    }

    @Override
    public void operate() {
        System.out.println("叶子："+name+"被调用");
    }
}

//树枝构建
class CompositeSafe implements ComponentSafe{

    private List childList = new ArrayList();

    public void add(ComponentSafe componentSafe){
        childList.add(componentSafe);
    }

    public void remove(ComponentSafe componentSafe){
        childList.remove(componentSafe);
    }

    public ComponentSafe getChild(int index){
        return childList.get(index);
    }

    @Override
    public void operate() {
        for(ComponentSafe componentSafe : childList){
            componentSafe.operate();
        }
    }
}

十七.命令模式

     命令模式Command将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开，这样两者之间通过命令对象进行沟通，这样方便将命令对象进行存储、传递、调用、增加和管理。

应用场景：

1.请求调用者需要和请求接收者解耦时，命令模式可以使调用者和接收者不直接交互；

2.系统随机请求命令或经常增加、删除命令时，命令模式可以方便的实现这些功能；

3.当系统需要支持命令的撤销（Undo）操作和恢复（Redo）操作时，可以将命令对象存储起来，采用备忘录模式来实现。

优点：

1.通过引入中间件（抽象接口）降低系统的耦合度；

2.扩展性良好，增加或删除命令非常方便，采用命令模式增加或删除命令不会影响其他类，且满足开闭原则；

3.可以实现宏命令，命令模式可以与组合模式结合，将多个命令装配成一个组合命令，即宏命令；

4.方便实现Undo和Redo操作，命令模式可以与备忘录模式结合使用，实现命令的撤销和恢复；

5.可以在现有命令的基础上，增加而外功能，例如日志记录。

public class CommandTest {
    public static void main(String[] args) {
        //创建翻上一个视频的命令对象
        Command upVideoCommand = new UpVideoCommand();
        //创建关闭电视机的命令对象
        Command closeVideoCommand = new CloseVideoCommand();
        //创建调用者
        ControllerInvoker controllerInvoker = new ControllerInvoker();
        //把可以调用的命令设置到调用者中
        controllerInvoker.setUpVideoCommand(upVideoCommand);
        controllerInvoker.setCloseVideoCommand(closeVideoCommand);
        //调用者调用方法-翻上一个视频
        controllerInvoker.upVideo();
        //调用者调用方法-关闭电视机
        controllerInvoker.closeVideo();
    }
}

//抽象命令类
interface Command{
    void execute();
}

//具体命令类-翻上一个视频操作
class UpVideoCommand implements Command{
    //注入此命令的接收者
    private VideoTopReceiver videoTopReceiver;

    public UpVideoCommand() {
        videoTopReceiver = new VideoTopReceiver();
    }

    @Override
    public void execute() {
        System.out.println("按了翻上一个视频的按钮");
        //给接收者发送命令
        videoTopReceiver.upVideo();
    }
}

//具体命令类-关闭电视机
class CloseVideoCommand implements Command{
    //注入此命令的接收者
    private VideoReceiver videoReceiver;

    public CloseVideoCommand() {
        videoReceiver = new VideoReceiver();
    }

    @Override
    public void execute() {
        System.out.println("按了关机的按钮");
        //给接收者发送命令
        videoReceiver.closeVideo();
    }
}

//命令实现者-电视机顶盒
class VideoTopReceiver {
    public void upVideo(){
        System.out.println("收到命令，翻上一个台");
    }
}

//命令实现者-电视机
class VideoReceiver{
    public void closeVideo(){
        System.out.println("收到命令，电视机关机");
    }
}

//调用者-遥控器，设置了可以调用的命令
class ControllerInvoker{
    //定义好有哪些命令可以调用
    private Command upVideoCommand,closeVideoCommand;

    public void setUpVideoCommand(Command upVideoCommand) {
        this.upVideoCommand = upVideoCommand;
    }

    public void setCloseVideoCommand(Command closeVideoCommand) {
        this.closeVideoCommand = closeVideoCommand;
    }

    //当按下调用上一个节目的按钮执行的方法
    public void upVideo(){
        upVideoCommand.execute();
    }

    //当按电视关机的按钮执行的方法
    public void closeVideo(){
        closeVideoCommand.execute();
    }
}

十八.状态模式

      状态模式State对有状态的对象，把复杂的判断逻辑提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。

应用场景：
1.当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式；

2.一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。

优点：

1.结构清晰，状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分隔开来，满足单一职责原则；

2.将状态转换化，减少对象间的相互依赖，将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖；

3.状态类职责明确，有利于程序的扩展，通过定义新的子类很容易的增加新的状态和转换。

例如：线程的状态转换

JAVA 23种设计模式示例_第10张图片

public class StateTest {
    public static void main(String[] args) {
        ThreadContext threadContext = new ThreadContext();
        //启动线程，方法执行前状态：新建，执行后状态：变为就绪
        threadContext.start();
        //获取到cpu资源，方法执行前状态：就绪，执行后状态：变为运行
        threadContext.getCpu();
        //中断线程，方法执行前状态：运行，执行后状态：变为阻塞
        threadContext.suspend();
        //恢复线程，方法执行前状态：阻塞，执行后状态：变为就绪
        threadContext.resume();
        //获取到cpu资源，方法执行前状态：就绪，执行后状态：变为运行
        threadContext.getCpu();
        //停止线程 ，方法执行前状态：运行，执行后状态：变为停止
        threadContext.stop();
    }
}

//环境类-存放全局的状态
class ThreadContext{
    //环境类里面放一个记录状态的类，通过该变此对象的值，来改变环境的状态
    ThreadState state;

    //创建环境类的时候，先默认给一个初始的state状态
    public ThreadContext() {
        state = new New();
    }

    //程序运行过程中获取状态
    public ThreadState getState() {
        return state;
    }

    //程序运行过程中，重新设置状态值
    public void setState(ThreadState state) {
        this.state = state;
    }

    //调用启动方法-状态为新建的时候
    public void start(){
        //把state抽象类强转成具体的子类，调用子类的方法，并把环境类传递过去，这样可以在此方法调用后改变state状态值
        ((New)state).start(this);
    }

    //调用获取cpu资源-状态为就绪的时候
    public void getCpu(){
        //把state抽象类强转成具体的子类，调用子类的方法，并把环境类传递过去，这样可以在此方法调用后改变state状态值
        ((Runnable)state).getCpu(this);
    }

    //调用线程中断-状态为运行的时候
    public void suspend(){
        //把state抽象类强转成具体的子类，调用子类的方法，并把环境类传递过去，这样可以在此方法调用后改变state状态值
        ((Running)state).suspend(this);
    }

    //调用线程结束-状态为运行的时候
    public void stop(){
        //把state抽象类强转成具体的子类，调用子类的方法，并把环境类传递过去，这样可以在此方法调用后改变state状态值
        ((Running)state).stop(this);
    }

    //调用线程结束-状态为阻塞的时候
    public void resume(){
        //把state抽象类强转成具体的子类，调用子类的方法，并把环境类传递过去，这样可以在此方法调用后改变state状态值
        ((Blocked)state).resume(this);
    }
}

//抽象状态类
abstract class ThreadState{
    String stateName;
}

//具体状态类-线程新建状态，可以调用启动方法
class New extends ThreadState{
    public New(){
        stateName = "新建状态";
        System.out.println("线程创建.");
    }

    public void start(ThreadContext threadContext){
        System.out.println("调用线程启动方法start()");
        if("新建状态".equals(stateName)){
            //重新设置环境类中state状态变量的值
            threadContext.setState(new Runnable());
        } else {
            System.out.println("线程没有处于新建状态，不允许启动线程");
        }
    }
}

//具体实现类-线程就绪状态，可以调用获取cpu资源的方法
class Runnable extends ThreadState{

    public Runnable() {
        stateName = "就绪状态";
        System.out.println("线程处于就绪状态");
    }

    public void getCpu(ThreadContext threadContext){
        System.out.println("调用线程获取资源方法getCpu()");
        if("就绪状态".equals(stateName)){
            //重新设置环境类中state状态变量的值
            threadContext.setState(new Running());
        } else {
            System.out.println("线程没有处于就绪状态，不允许获取资源");
        }
    }
}

//具体实现类-线程运行状态，可以调用中断、结束线程的方法
class Running extends ThreadState{

    public Running() {
        stateName = "运行状态";
        System.out.println("线程处于运行状态");
    }

    public void suspend(ThreadContext threadContext){
        System.out.println("调用线程中断方法suspend()");
        if("运行状态".equals(stateName)){
            //重新设置环境类中state状态变量的值
            threadContext.setState(new Blocked());
        } else {
            System.out.println("线程没有处于运行状态，不允许中断");
        }
    }

    public void stop(ThreadContext threadContext){
        System.out.println("调用线程结束方法stop()");
        if("运行状态".equals(stateName)){
            //重新设置环境类中state状态变量的值
            threadContext.setState(new Stop());
        } else {
            System.out.println("线程没有处于运行状态，不允许结束");
        }
    }
}

//具体实现类-线程阻塞状态，可以调用恢复线程的方法
class Blocked extends ThreadState{

    public Blocked() {
        stateName = "阻塞状态";
        System.out.println("线程处于阻塞状态");
    }

    public void resume(ThreadContext threadContext){
        System.out.println("调用线程恢复方法resume()");
        if("阻塞状态".equals(stateName)){
            //重新设置环境类中state状态变量的值
            threadContext.setState(new Runnable());
        } else {
            System.out.println("线程没有处于阻塞状态，不允许恢复");
        }
    }
}

//具体实现类-线程结束状态
class Stop extends ThreadState{

    public Stop() {
        stateName = "结束状态";
        System.out.println("线程处于结束状态");
    }
}

十九.中介者模式

     中介者模式Mediator定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立的改变他们之间的交互。

应用场景：

1.当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时；

2.当想创建一个运行于多个类之间的对象，又不想生成新的子类时。

优点：

1.类之间各司其职，符合迪米特法则；

2.降低了对象之间的耦合性，使得对象易于独立的被复用；

3.将对象之间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。

例如：中介者结构图的实现

JAVA 23种设计模式示例_第11张图片

public class MediatorTest {
    public static void main(String[] args) {
        //创建中介者
        Mediator mediator = new ConcreteMediator();
        //创建同事类
        Colleague concreteColleague1 = new ConcreteColleague1();
        Colleague concreteColleague2 = new ConcreteColleague2();
        //把同事类添加到中介者中
        mediator.register(concreteColleague1);
        mediator.register(concreteColleague2);
        //同事类发送消息
        concreteColleague1.send();
        concreteColleague2.send();
    }
}

//抽象中介者
abstract class Mediator{
    //同事类添加到中介者中
    abstract void register(Colleague colleague);
    //转发消息
    abstract void relay(Colleague colleague);
}

//抽象同事类
abstract class Colleague{
    //记录此同事类关联的中介者
    Mediator mediator;
    //接收消息
    abstract void receive();
    //发送消息
    abstract void send();

    //设置此同事类关联的中介者
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }
}

//具体中介者
class ConcreteMediator extends Mediator{
    //记录注册在此中介者中的同事集合
    private List list = new ArrayList();

    @Override
    void register(Colleague colleague) {
        if(!list.contains(colleague)){
            //把同事类添加到它关联的中介者中
            list.add(colleague);
            //给此同事类设置它关联的中介者
            colleague.setMediator(this);
        }
    }

    @Override
    void relay(Colleague c) {
        for(Colleague colleague : list){
            //转发的同事，不包含发消息的同事
            if(!c.equals(colleague)){
                colleague.receive();
            }
        }
    }
}

//具体同事类
class ConcreteColleague1 extends Colleague{

    @Override
    void receive() {
        System.out.println("具体同事类1收到消息");
    }

    @Override
    void send() {
        System.out.println("具体同事类1发送消息");
        //通过此同事类关联的中介者进行消息转发（不包含转发给自己）
        mediator.relay(this);
    }
}

//具体同事类
class ConcreteColleague2 extends Colleague{

    @Override
    void receive() {
        System.out.println("具体同事类2收到消息");
    }

    @Override
    void send() {
        System.out.println("具体同事类2发送消息");
        //通过此同事类关联的中介者进行消息转发（不包含转发给自己）
        mediator.relay(this);
    }

二十.迭代器模式

      迭代器模式Iterator提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

应用场景：

1.当需要为聚合对象提供多种遍历方式时；

2.当需要为遍历不同的聚合结构提供一个统一的接口时；

3.当访问一个聚合对象的内容而无须暴露其内部细节的表示时。

优点：

1.访问一个聚合对象的内容而无须暴露它的内部表示；

2.遍历任务交由迭代器完成，这简化了聚合类；

3.它支持以不同方式遍历一个聚合，甚至可以自定义迭代器的子类以支持新的遍历；

4.增加新的聚合类和迭代器类都很方便，无须修改原有代码；

5.封装性良好，为遍历不同的聚合结构提供一个统一的接口。

public class IteratorTest {

    public static void main(String[] args) {
        //创建聚合类
        Aggegate concreteAggegate = new ConcreteAggegate();
        //向聚合类中添加对象
        concreteAggegate.add("苹果");
        concreteAggegate.add("橘子");
        concreteAggegate.add("香蕉");
        concreteAggegate.add("芒果");
        //把聚合类中的集合对象作为参数传递到迭代器中，创建迭代器
        Iterator iterator = concreteAggegate.getIterator();
        //遍历数据
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("遍历结束");
        System.out.println(iterator.first());
        System.out.println(iterator.hasNext());
        System.out.println(iterator.next());
        System.out.println(iterator.previous());
        System.out.println(iterator.last());
        System.out.println(iterator.hasNext());
    }
}

//聚合抽象类
interface Aggegate{
    //添加元素到集合中
    void add(Object object);
    //从集合中移出元素
    void remove(Object object);
    //获得迭代器
    Iterator getIterator();
}

//抽象迭代器类
interface Iterator{
    //获取第一个元素
    Object first();
    //获取下一个元素
    Object next();
    //获取前一个元素
    Object previous();
    //获取最后一个元素
    Object last();
    //是否还有下一个元素
    boolean hasNext();
}

//具体聚合类
class ConcreteAggegate implements Aggegate{
    //定义一个集合，用于存放加入到聚合类中的对象
    private List list = new ArrayList();

    @Override
    public void add(Object object) {
        list.add(object);
    }

    @Override
    public void remove(Object object) {
        list.remove(object);
    }

    @Override
    public Iterator getIterator() {
        return new ConcreteIterator(list);
    }
}

//具体迭代器
class ConcreteIterator implements Iterator{
    //定义一个集合，用于接收聚合类中的集合对象
    private List list = new ArrayList();
    //迭代器的索引
    int index = -1;

    public ConcreteIterator(List list) {
        this.list = list;
    }

    @Override
    public Object first() {
        index = 0;
        return list.get(index);
    }

    @Override
    public Object next() {
        if(this.hasNext()){
            return list.get(++index);
        }
        return null;
    }

    @Override
    public Object previous() {
        if(index > 0) {
            return list.get(--index);
        }else {
            return null;
        }
    }

    @Override
    public Object last() {
        index = list.size()-1;
        return list.get(index);
    }

    @Override
    public boolean hasNext() {
        if(index >= list.size()-1){
            return false;
        }
        return true;
    }
}


二十一.访问者模式


      访问者模式visitor将作用于某种数据结构中的各元素的操作分离出来分装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方式，它将对数据的操作与数据结构进行分离。


应用场景：


1.对象结构相对稳定，但其操作算法经常变化的程序；


2.对象结构中的对象需要提供多种不同且不相关的操作，而且要避免让这些操作的变化影响对象的结构。


3.对象结构包含很多类型的对象，希望对这些对象实施一些依赖于其具体类型的操作。


优点：


1.扩展性好，能够在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能；


2.复用性好，可以通过访问者来定义整个对象结构通用的功能，从而提高系统的复用程度；


3.灵活性好，访问者模式将数据结构和作用于结构上的操作解耦，是的操作集合可相对自由的演化而不影响系统的数据结构；


4.符合单一职责原则，访问者模式把相关的行为封装在一起，构成一个访问者，使每个访问者的功能都比较单一。


public class VisitorTest {
    public static void main(String[] args) {
        //创建结构对象
        ObjectStructure objectStructure = new ObjectStructure();
        //添加可以访问的元素
        ConcreteElements1 concreteElements1 = new ConcreteElements1();
        ConcreteElements2 concreteElements2 = new ConcreteElements2();
        objectStructure.add(concreteElements1);
        objectStructure.add(concreteElements2);
        //创建访问对象
        Visitor visitor = new ConcreteVisitor1();
        //结构对象接受visitor访问者的访问，遍历结构对象中存的所有元素接受访问
        objectStructure.accept(visitor);
    }
}

//抽象访问者
interface Visitor{
    //访问哪个元素，元素作为参数
    void visit(ConcreteElements1 elements);
    void visit(ConcreteElements2 elements);
}

//抽象元素
interface Elements{
    //接收谁的访问，访问者作为参数传递进来
    void accept(Visitor vistor);
}

//具体访问者
class ConcreteVisitor1 implements Visitor{

    @Override
    public void visit(ConcreteElements1 elements) {
        System.out.print("具体访问者1访问-》");
        elements.operator1();
    }

    @Override
    public void visit(ConcreteElements2 elements) {
        System.out.print("具体访问者1访问-》");
        elements.operator2();
    }
}

//具体元素
class ConcreteElements1 implements Elements{

    //元素接收访问
    @Override
    public void accept(Visitor visitor) {
        //当前元素接受visitor的访问，调用visitor的访问方法
        visitor.visit(this);
    }

    public void operator1(){
        System.out.println("元素1");
    }
}

//具体元素
class ConcreteElements2 implements Elements{

    //元素接收访问
    @Override
    public void accept(Visitor visitor) {
        //当前元素接受visitor的访问
        visitor.visit(this);
    }

    public void operator2(){
        System.out.println("元素2");
    }
}

//对象结构
class ObjectStructure{
    //存放有哪些元素可以访问
    List list = new ArrayList();

    //添加元素到集合
    public void add(Elements elements){
        list.add(elements);
    }

    //接受访问-接受谁的方法，作为参数传递进来
    public void accept(Visitor visitor){
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            //让元素接受某个访问者的访问
            iterator.next().accept(visitor);
        }

    }

}



二十二.备忘录模式


       备忘录模式Memento在不破坏封装性的前提下，捕获一个对象的内部状态，并在改对象之外保存这个状态，以便以后当需要时能将该对象恢复到原先保存的状态，该模式又叫快照模式。


应用场景：


1.需要保存与恢复数据的场景，如玩游戏时的中间结果存档功能；


2.需要提供一个可回滚操作的场景，如Word、记事本、Photoshop、Eclipse等软件在编辑时按Ctrl+Z组合键，还有数据库中事务操作。


优点：


1.提供了一种可以恢复状态的机制，当用户需要时能够比较方便的将数据恢复到某个历史状态；


2.实现了内部状态的封装，除了创建它的发起人之外，其它对象都不能够访问这些状态信息；


3.简化了发起人类，发起人不需要管理和保存其内部状态的各个备份，所有状态信息都保存在备忘录中，并由管理者进行管理，这符合单一职责原则。


public class MementoTest {
    public static void main(String[] args) {
        //创建管理者
        Caretaker caretaker = new Caretaker();
        //创建发起者
        Originator originator = new Originator();
        originator.setState("0");
        //创建备份
        Memento memento = originator.createMemento();
        //备份添加到管理者中
        caretaker.push(memento);
        originator.setState("1");
        //备份添加到管理者中
        caretaker.push(originator.createMemento());
        originator.setState("2");
        System.out.println("当前状态值:"+originator.getState());
        //第一次还原
        originator.restoreMemento(caretaker.pop());
        System.out.println("第一次还原状态值:"+originator.getState());
        //第二次还原
        originator.restoreMemento(caretaker.pop());
        System.out.println("第二次还原状态值:"+originator.getState());
    }
}

//备忘录实体-需要记录发起人存放的所有字符值
class Memento{
    //字段，与发起人实体中相同的字段
    private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

//发起人角色
class Originator{
    private String state;

    //创建备份录
    public Memento createMemento(){
        //把需要备份的字段都传递到备份类实体中进行备份
        return new Memento(state);
    }

    //恢复备份-通过某个备份文件还原当前发起人的数据
    public void restoreMemento(Memento memento){
        //把备份类记录的值还原到发起人类对应的字段中
        this.state = memento.getState();
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }
}

//管理者-记录着备份的对象
class Caretaker{
    //使用栈记录备份的记录，栈的特性：先进后出，符合还原操作
    private Stack stack = new Stack();

    //添加备份到栈
    public void push(Memento memento) {
        stack.push(memento);
    }

    //还原时，从栈中拿出备份的记录
    public Memento pop(){
        return stack.pop();
    }
}



二十三.解释器模式


      解释器模式Interpreter给分析对象定义一个语言，并定义该语言的文法表示，再设计一个解析器来解释语言中的句子。也就是说，用编译语言的方式来分析应用中的实例，这种模式实现了文法表达式处理的接口，该接口解释一个特定的上下文。


应用场景：


1.当语言的文法比较简单，且执行效率不是关键问题时；


2.当问题重复出现，且可以用一种简单的语言来进行表达时；


3.当一个语言需要解释执行，并且语言中的句子可以表示为一个抽象语法树的时候。


优点：


1.扩展性好，由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法；


2.容易实现，在语法树中的每个表达式节点类都是相似的，所以实现其文法较为简单。


public class InterpreterTest {
    public static void main(String[] args) {
        Context context = new Context();
        context.checkMes("军人的子女");
        context.checkMes("军人的妻子");
        context.checkMes("工人的子女");
        context.checkMes("警察的父母");
        context.checkMes("警察的朋友");
    }
}

//抽象表达式
interface AbstractExpression{
    //接收某个输入的信息
    boolean interprete(String info);
}

//终结者表达式-名词、代词
class TerminalExpression implements AbstractExpression{

    //定义集合存放允许的词
    private List list = new ArrayList();

    //创建对象时，需要给出允许的词
    public TerminalExpression(String[] arrStr) {
        for(int i = 0;i < arrStr.length;i++){
            list.add(arrStr[i]);
        }
    }

    @Override
    public boolean interprete(String info) {
        //包含这个此，返回true
        if(list.contains(info)){
            return true;
        }
        return false;
    }
}

//非终结者表达式-谓语（动词）
class NonTerminalExpression implements AbstractExpression{
    //记录终结者表达式的对象
    private AbstractExpression jobExpression;
    private AbstractExpression persionExpression;

    public NonTerminalExpression(AbstractExpression jobExpression, AbstractExpression persionExpression) {
        this.jobExpression = jobExpression;
        this.persionExpression = persionExpression;
    }

    @Override
    public boolean interprete(String info) {
        //非终结者进行分词
        String[]  arr = info.split("的");
        //判断是否包含
        return jobExpression.interprete(arr[0]) && persionExpression.interprete(arr[1]);
    }
}

//环境角色
class Context{
    //定义允许的此
    String[] jobArr = {"军人","警察"};
    String[] persionArr = {"父母","子女"};

    //定义一个非终结表达式对象
    AbstractExpression nonTerminalExpression;

    public Context() {
        //创建终结者表达式对象
        TerminalExpression job = new TerminalExpression(jobArr);
        TerminalExpression persion = new TerminalExpression(persionArr);
        nonTerminalExpression = new NonTerminalExpression(job, persion);
    }

    //输入一个字符判断是否符合表达式
    public void checkMes(String info){
        boolean interprete = nonTerminalExpression.interprete(info);
        if(interprete){
            System.out.println(info+"可以享受优先的政策");
        } else {
            System.out.println(info+"正常排队");
        }
    }
}





























你可能感兴趣的:(知识笔记,程序人生,java,设计模式,单例模式,工厂模式,代理模式)






    

  • 华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）
华为OD题库
华为od链表java

    须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
    

    • 

  • 学习JavaEE的日子 Day32 线程池
A 北枝
学习JavaEE学习java-eejava线程池

    Day32线程池1.引入一个线程完成一项任务所需时间为：创建线程时间-Time1线程中执行任务的时间-Time2销毁线程时间-Time32.为什么需要线程池(重要)线程池技术正是关注如何缩短或调整Time1和Time3的时间，从而提高程序的性能。项目中可以把Time1，T3分别安排在项目的启动和结束的时间段或者一些空闲的时间段线程池不仅调整Time1，Time3产生的时间段，而且它还显著减少了创建
    

    • 

  • 请简单介绍一下Shiro框架是什么？Shiro在Java安全领域的主要作用是什么？Shiro主要提供了哪些安全功能？
AaronWang94
shirojavajava安全开发语言

    请简单介绍一下Shiro框架是什么？Shiro框架是一个强大且灵活的开源安全框架，为Java应用程序提供了全面的安全解决方案。它主要用于身份验证、授权、加密和会话管理等功能，可以轻松地集成到任何JavaWeb应用程序中，并提供了易于理解和使用的API，使开发人员能够快速实现安全特性。Shiro的核心组件包括Subject、SecurityManager和Realms。Subject代表了当前与应用
    

    • 

  • 通俗易懂：什么是Java虚拟机（JVM）？它的主要作用是什么？
大龄下岗程序员
mysqljavamysqlspring

    Java虚拟机（JavaVirtualMachine,JVM）是一种软件实现的抽象计算机，它负责执行Java字节码（Bytecode）。Java程序并不是直接在物理计算机上运行，而是先由Java编译器将源代码编译成与平台无关的字节码，然后由JVM负责读取字节码并在实际硬件架构上运行。JVM的主要作用包括以下几个方面：1.跨平台性-JVM是Java语言“一次编写，到处运行”（WriteOnce,Ru
    

    • 

  • 3、JavaWeb-Ajax/Axios-前端工程化-Element
所谓远行Misnearch
#JavaWeb前端ajaxelementuijava前端框架

    P34Ajax介绍Ajax:AsynchroousJavaScriptAndXML，异步的JS和XMLJS网页动作，XML一种标记语言，存储数据，作用：数据交换：通过Ajax给服务器发送请求，并获取服务器响应的数据异步交互：在不重新加载整个页面的情况下，与服务器交换数据并实现更新部分网页的技术，例如：搜索联想、用户名是否可用的校验等等。同步与异步：同步：服务器在处理中客户端要处于等待状态，输入域名
    

    • 

  • 枚举使用笔记
万变不离其宗_8
项目笔记笔记

    1.java枚举怎么放在方法上面的注释里面/***保存*@paramuserId用户id*@paramtype见枚举{@linkcom.common.enums.TypeEnum}*@return*/voidsave(LonguserId,Stringtype);
    

    • 

  • Python dict字符串转json对象，小数精度丢失问题
朝如青丝 暮成雪
jsonpython

    一前言JSON(JavaScriptObjectNotation)是一种轻量级的数据交换格式，dict是Python的一种数据格式。本篇介绍一个float数据转换时精度丢失的案例。二问题描述importjsontest_str1='{"π":3.1415926535897932384626433832795028841971}'test_str2='{"value":10.00000}'print
    

    • 

  • java实体中返回前端的double类型四舍五入（格式化）
婲落ヽ紅顏誶
java

    根据业务，需要通过后端给前端返回部分double类型的数值，一般需要保留两位小数，使用jackson转换对象packagecom.ruoyi.common.core.config;importcom.fasterxml.jackson.core.JsonGenerator;importcom.fasterxml.jackson.databind.JsonSerializer;importcom.f
    

    • 

  • Java中HashMap底层数据结构及主要参数?
山间漫步人生路
java数据结构开发语言

    在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
    

    • 

  • C语言演示多线程编程条件下自旋锁和屏障的使用
嫦娥妹妹等等我
开发语言c语言开源

    主线故事:有4个人玩游戏输了,惩罚:1分别使用4台不同的ATM机给我存钱2必须一块一块的存3存完还得在ATM上看一下我的余额设计模式:1每个人使用一条单独的线程,再准备一个计时线程用来输出时间2存钱涉及到对共享资源的读写,是原子操作需要用锁保护这里使用自旋锁3都存完钱后需要等待在各自的ATM上回显余额这里使用屏障技术4如果在主线程中回显对应他们给我打电话告诉我存完了我自己看一下则不需要使用屏障因为
    

    • 

  • Java学习笔记01
.wsy.
日常java学习笔记

    1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
    

    • 

  • Java回溯知识点（含面试大厂题和源码）
一成码农
java面试开发语言

    回溯算法是一种通过遍历所有可能的候选解来寻找所有解的算法，如果候选解被确认不是一个解（或至少不是最后一个解），回溯算法会通过在上一步进行一些变化来丢弃这个解，即“回溯”并尝试另一个候选解。回溯法通常用递归方法来实现，在解决排列、组合、选择问题时非常有效。回溯算法的核心要点：路径：也就是已经做出的选择。选择列表：也就是你当前可以做的选择。结束条件：也就是到达决策树底层，无法再做出选择的条件。回溯算法
    

    • 

  • Azkaban各种类型的Job编写
__元昊__

    一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
    

    • 

  • java基础相关面试题详细总结
。。。。。96
java开发语言

    1.Java中的数据类型有哪些？答：Java中的数据类型包括基本数据类型（如整数、浮点数、字符等）和引用数据类型（如类、接口、数组等）。2.什么是面向对象编程（OOP）？答：面向对象编程是一种编程范式，它将数据和对数据的操作封装在一起，形成对象。通过对象之间的交互来实现程序的功能。3.解释类和对象的关系。答：类是对象的抽象描述，而对象是类的具体实例。一个类可以创建多个对象，每个对象都具有类中定义的
    

    • 

  • 【二】【设计模式】建造者模式
妖精七七_
设计模式设计模式建造者模式

    建造者模式的引入//C10_1.cpp#include#include"SystemConfig.h"intmain(){SystemConfigconfig("mysql://127.0.0.1/","xiaomu","xiaomumemeda","redis://127.0.0.1/","xiaomuredis","xiaomuredispw","kafka://127.0.0.1","xia
    

    • 

  • 大话设计模式之工厂模式
码农客栈
设计模式开发语言

    工厂模式（FactoryPattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式，而无需指定将要创建的对象的确切类。通过使用工厂模式，我们可以将对象的创建和使用分离，从而使代码更具灵活性和可维护性。在工厂模式中，通常会有三种角色：工厂接口（FactoryInterface）：声明了一个用于创建对象的接口，这样所有具体工厂类都必须实现该接口。具体工厂（ConcreteFactory）：实
    

    • 

  • javascript 日期转换为时间戳，时间戳转换为日期的函数
cdcdhj
javascript学习日记javascript开发语言ecmascript

    日期转化为时间戳，主要用valueOf()来进行转化为毫秒时间戳，getTime()IOS系统无法解析转换，所以都有valueOf()letgetTimestampOrDate=function(timestamp){lettimeStamp='';constregex=/^\d{4}(-|\/)\d{2}(-|\/)\d{2}$/;constregex2=/^\d{4}(-|\/)\d{2}(-
    

    • 

  • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法
杰哥在此
Java系列javajvm算法面试

    Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
    

    • 

  • COMP315 JavaScript Cloud Computing for E Commerce
zhuyu0206girl
javascript开发语言ecmascript

    Assignment1:Javascript1IntroductionAcommontaskincloudcomputingisdatacleaning,whichistheprocessoftakinganinitialdatasetthatmaycontainerroneousorincompletedata,andremovingorfixingthoseelementsbeforeform
    

    • 

  • JSON与AJAX：网页交互的利器
入冉心
jsonajax前端

    在现代Web开发中，JSON（JavaScriptObjectNotation）和AJAX（AsynchronousJavaScriptandXML）是两项不可或缺的技术。它们共同为网页提供了动态、实时的数据交互能力，为用户带来了更加流畅和丰富的体验。本文将详细介绍JSON和AJAX的概念、原理，并通过代码示例展示它们在实际开发中的应用。一、JSON：轻量级的数据交换格式JSON是一种轻量级的数据
    

    • 

  • 《外观模式（极简c++）》
Bovinitwo
设计模式（极简c++版）c++开发语言

    本文章属于专栏-概述-《设计模式（极简c++版）》-CSDN博客模式说明方案：外观模式提供了一个统一的接口，简化了一组复杂子系统的访问方式。优点：将客户端与子系统解耦，降低了复杂性。提高了代码的灵活性和可维护性。缺点：可能导致外观类过于庞大，承担了过多的责任。增加了系统的抽象层，有时会影响性能。本质思想：外观模式的本质思想是为一组复杂的子系统提供一个简单的接口，隐藏其复杂性，使得客户端可以更轻松地
    

    • 

  • 程序员开发技术整理
laizhixue
学习前端框架

    前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
    

    • 

  • 大话设计模式之代理模式
码农客栈
设计模式代理模式

    代理模式（ProxyPattern）是一种结构型设计模式，它允许通过代理对象控制对另一个对象的访问。代理对象充当客户端和实际对象之间的中介，客户端通过代理对象间接访问实际对象，从而可以在访问控制、缓存、延迟加载等方面提供额外的功能。在代理模式中，通常会有三种角色：Subject（抽象主题）：声明了真实对象和代理对象的共同接口，这样在任何使用真实对象的地方都可以使用代理对象。RealSubject（
    

    • 

  • C#学习笔记
2301_79022588
学习笔记

    一、事件派发器在C#中，事件派发器通常是指事件委托和事件处理程序的组合，用于实现一种观察者设计模式。它允许对象在状态发生变化时通知其他对象，从而实现对象之间的解耦。事件派发器的基本组成部分：事件委托（EventDelegate）：事件委托是一种特殊的委托，用于封装可以被调用的方法。它定义了事件的签名，即指定了事件处理程序方法的参数和返回类型。通常，事件委托声明在事件派发器类的外部，并且使用dele
    

    • 

  • javascript的数据类型及转换
田小田txt

    一、JavaScript数据类型：共有string，number，boolean，object，function五种数据类型；其中Object，Date，Array为对象型；2个不包含任何值的数据类型：null，undefined。二、Typeof查看数据类型：typeof"John"//返回stringtypeof3.14//返回numbertypeofNaN//返回numbertypeoffa
    

    • 

  • java线程之Lock的使用
dimdark

    目标:大致介绍一下java.util.concurrent.locks包下的类,接口及其常用方法1.Lock接口Lock接口使用Lock接口的最佳模式:publicvoidmethod()throwInterruptedException{try{lock.lock();//lock.lockUninterruptibly();}finally{lock.unlock();}}用户必须手动释放Lo
    

    • 

  • 第六届蓝桥杯大赛软件赛省赛Java 大学C组题解
爱跑步的程序员~
刷题蓝桥杯省赛

    文章目录A隔行变色思路解题方法复杂度CodeB立方尾不变思路解题方法复杂度CodeC无穷分数思路解题方法复杂度CodeD奇妙的数字思路解题方法复杂度CodeE移动距离思路解题方法复杂度CodeF垒骰子思路解题方法复杂度CodeA隔行变色思路这是一个简单的计数问题。我们需要找出21到50之间的奇数数量。奇数行将被染成蓝色，偶数行将被染成白色。解题方法我们可以使用一个for循环从21遍历到50，然后使
    

    • 

  • Java学习笔记04：Java_数组
JasonYangQ
Javajava

    文章目录1.数组1.1数组介绍1.2数组的定义格式1.2.1第一种格式1.2.2第二种格式1.3数组的动态初始化1.3.1什么是动态初始化1.3.2动态初始化格式1.3.3动态初始化格式详解1.4数组元素访问1.4.1什么是索引1.4.2访问数组元素格式1.4.3示例代码1.5内存分配1.5.1内存概述1.5.2java中的内存分配1.9数组的静态初始化1.9.1什么是静态初始化1.9.2静态初始
    

    • 

  • 【设计模式】Java 设计模式之桥接模式（Bridge）
新手村长
Java设计模式设计模式java桥接模式

    桥接模式（BridgePattern）是结构型设计模式的一种，它主要解决的是抽象部分与实现部分的解耦问题，使得两者可以独立变化。这种类型的设计模式属于结构型模式，因为该模式涉及如何组合接口和它们的实现。将抽象部分与实现部分分离，使它们都可以独立地变化。一、桥接模式概述桥接模式的主要思想是将抽象与实现进行解耦，使得二者可以独立进行变化。在桥接模式中，抽象部分和实现部分被分离出来，抽象部分定义了一个抽
    

    • 

  • C++面试题
虾仁A
面试c++

    目录一、堆和栈的区别二、C++中new、delte和malloc的区别三、什么是源对象四、C++有哪些设计模式五，你使用过C++哪些类型的指针一、堆和栈的区别特性堆栈申请方式由程序员显式申请和释放由系统自动分配和释放分配方式动态分配自动分配分配效率相对较慢，需要遍历内存链表寻找合适空间相对较快，系统直接分配内存地址不连续的内存区域连续的内存区域大小限制大小灵活，上限取决于虚拟内存大小固定，通常较小
    

    • 

  • rust的指针作为函数返回值是直接传递，还是先销毁后创建？
wudixiaotie
返回值

     这是我自己想到的问题，结果去知呼提问，还没等别人回答， 我自己就想到方法实验了。。
fn main() {
let mut a = 34;
println!("a's addr:{:p}", &a);
let p = &mut a;
println!("p's addr:{:p}", &a
    

    • 

  • java编程思想 -- 数据的初始化
百合不是茶
java数据的初始化

     
1.使用构造器确保数据初始化
    
/*
*在ReckInitDemo类中创建Reck的对象
*/
public class ReckInitDemo {
public static void main(String[] args) {
//创建Reck对象
new Reck();
}
}
    

    • 

  • [航天与宇宙]为什么发射和回收航天器有档期
comsci

    
       地球的大气层中有一个时空屏蔽层,这个层次会不定时的出现,如果该时空屏蔽层出现,那么将导致外层空间进入的任何物体被摧毁,而从地面发射到太空的飞船也将被摧毁...
       所以,航天发射和飞船回收都需要等待这个时空屏蔽层消失之后,再进行
&
    

    • 

  • linux下批量替换文件内容
商人shang
linux替换

    1、网络上现成的资料
　　格式: sed -i "s/查找字段/替换字段/g" `grep 查找字段 -rl 路径`
　　linux sed 批量替换多个文件中的字符串
　　sed -i "s/oldstring/newstring/g" `grep oldstring -rl yourdir`
　　例如：替换/home下所有文件中的www.admi
    

    • 

  • 网页在线天气预报
oloz
天气预报

    网页在线调用天气预报
<%@ page language="java" contentType="text/html; charset=utf-8"
pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transit
    

    • 

  • SpringMVC和Struts2比较
杨白白
springMVC

    1. 入口
spring mvc的入口是servlet，而struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这样就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。
参见：http://blog.csdn.net/zs15932616453/article/details/8832343
2
    

    • 

  • refuse copy, lazy girl!
小桔子
copy

           妹妹坐船头啊啊啊啊！都打算一点点琢磨呢。文字编辑也写了基本功能了。。今天查资料，结果查到了人家写得完完整整的。我清楚的认识到：
1.那是我自己觉得写不出的高度
2.如果直接拿来用，很快就能解决问题
3.然后就是抄咩~~
4.肿么可以这样子，都不想写了今儿个，留着作参考吧！拒绝大抄特抄，慢慢一点点写！
  
    

    • 

  • apache与php整合
aichenglong
php apache web

    一  apache web服务器
1 apeche web服务器的安装
  1)下载Apache web服务器
  2)配置域名(如果需要使用要在DNS上注册)
  3)测试安装访问http://localhost/验证是否安装成功
2 apache管理
  1)service.msc进行图形化管理
  2)命令管理，配
    

    • 

  • Maven常用内置变量
AILIKES
maven

    Built-in properties
${basedir} represents the directory containing pom.xml
${version} equivalent to ${project.version} (deprecated: ${pom.version})
Pom/Project properties
Al
    

    • 

  • java的类和对象
百合不是茶
JAVA面向对象 类 对象

    java中的类：
 
  java是面向对象的语言，解决问题的核心就是将问题看成是一个类，使用类来解决
 
java使用 class 类名   来创建类 ，在Java中类名要求和构造方法，Java的文件名是一样的
 
创建一个A类：
class A{
}
 
java中的类：将某两个事物有联系的属性包装在一个类中，再通
    

    • 

  • JS控制页面输入框为只读
bijian1013
JavaScript

    在WEB应用开发当中，增、删除、改、查功能必不可少，为了减少以后维护的工作量，我们一般都只做一份页面，通过传入的参数控制其是新增、修改或者查看。而修改时需将待修改的信息从后台取到并显示出来，实际上就是查看的过程，唯一的区别是修改时，页面上所有的信息能修改，而查看页面上的信息不能修改。因此完全可以将其合并，但通过前端JS将查看页面的所有信息控制为只读，在信息量非常大时，就比较麻烦。
  
    

    • 

  • AngularJS与服务器交互
bijian1013
JavaScriptAngularJS$http

            对于AJAX应用（使用XMLHttpRequests）来说，向服务器发起请求的传统方式是：获取一个XMLHttpRequest对象的引用、发起请求、读取响应、检查状态码，最后处理服务端的响应。整个过程示例如下：
var xmlhttp = new XMLHttpRequest();
xmlhttp.onreadystatechange
    

    • 

  • [Maven学习笔记八]Maven常用插件应用
bit1129
maven

    常用插件及其用法位于：http://maven.apache.org/plugins/
 
1. Jetty server plugin
2. Dependency copy plugin
3. Surefire Test plugin
4. Uber jar plugin
 
 
 
 
 
1. Jetty Pl
    

    • 

  • 【Hive六】Hive用户自定义函数(UDF)
bit1129
自定义函数

    1. 什么是Hive UDF
Hive是基于Hadoop中的MapReduce，提供HQL查询的数据仓库。Hive是一个很开放的系统，很多内容都支持用户定制，包括：
文件格式：Text File，Sequence File
内存中的数据格式： Java Integer/String, Hadoop IntWritable/Text
用户提供的 map/reduce 脚本：不管什么
    

    • 

  • 杀掉nginx进程后丢失nginx.pid，如何重新启动nginx
ronin47
nginx 重启 pid丢失

    nginx进程被意外关闭，使用nginx -s reload重启时报如下错误：nginx: [error] open() “/var/run/nginx.pid” failed (2: No such file or directory)这是因为nginx进程被杀死后pid丢失了，下一次再开启nginx -s reload时无法启动解决办法：nginx -s reload 只是用来告诉运行中的ng
    

    • 

  • UI设计中我们为什么需要设计动效
brotherlamp
UIui教程ui视频ui资料ui自学

    随着国际大品牌苹果和谷歌的引领，最近越来越多的国内公司开始关注动效设计了，越来越多的团队已经意识到动效在产品用户体验中的重要性了，更多的UI设计师们也开始投身动效设计领域。
但是说到底，我们到底为什么需要动效设计？或者说我们到底需要什么样的动效？做动效设计也有段时间了，于是尝试用一些案例，从产品本身出发来说说我所思考的动效设计。
一、加强体验舒适度
嗯，就是让用户更加爽更加爽的用你的产品。 
    

    • 

  • Spring中JdbcDaoSupport的DataSource注入问题
bylijinnan
javaspring

    参考以下两篇文章：
http://www.mkyong.com/spring/spring-jdbctemplate-jdbcdaosupport-examples/
http://stackoverflow.com/questions/4762229/spring-ldap-invoking-setter-methods-in-beans-configuration
Sprin
    

    • 

  • 数据库连接池的工作原理
chicony
数据库连接池

           随着信息技术的高速发展与广泛应用，数据库技术在信息技术领域中的位置越来越重要，尤其是网络应用和电子商务的迅速发展，都需要数据库技术支持动 态Web站点的运行，而传统的开发模式是：首先在主程序（如Servlet、Beans）中建立数据库连接；然后进行SQL操作，对数据库中的对象进行查 询、修改和删除等操作；最后断开数据库连接。使用这种开发模式，对
    

    • 

  • java 关键字
CrazyMizzz
java

    
关键字是事先定义的，有特别意义的标识符，有时又叫保留字。对于保留字，用户只能按照系统规定的方式使用，不能自行定义。
Java中的关键字按功能主要可以分为以下几类：
   （1）访问修饰符
      public,private,protected
      p
    

    • 

  • Hive中的排序语法
daizj
排序hiveorder byDISTRIBUTE BYsort by

    Hive中的排序语法 2014.06.22 ORDER BY
hive中的ORDER BY语句和关系数据库中的sql语法相似。他会对查询结果做全局排序，这意味着所有的数据会传送到一个Reduce任务上，这样会导致在大数量的情况下，花费大量时间。
与数据库中 ORDER BY 的区别在于在hive.mapred.mode = strict模式下，必须指定 limit 否则执行会报错。
    

    • 

  • 单态设计模式
dcj3sjt126com
设计模式

      单例模式（Singleton）用于为一个类生成一个唯一的对象。最常用的地方是数据库连接。 使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。
<?phpclass Example{    // 保存类实例在此属性中    private static&
    

    • 

  • svn locked
dcj3sjt126com
Lock

    post-commit hook failed (exit code 1) with output:
svn: E155004: Working copy 'D:\xx\xxx' locked
svn: E200031: sqlite: attempt to write a readonly database
svn: E200031: sqlite: attempt to write a 
    

    • 

  •  ARM寄存器学习
e200702084
数据结构C++cC#F#

    无论是学习哪一种处理器，首先需要明确的就是这种处理器的寄存器以及工作模式。
    ARM有37个寄存器，其中31个通用寄存器，6个状态寄存器。
1、不分组寄存器（R0-R7）
    不分组也就是说说，在所有的处理器模式下指的都时同一物理寄存器。在异常中断造成处理器模式切换时，由于不同的处理器模式使用一个名字相同的物理寄存器，就是
    

    • 

  • 常用编码资料
gengzg
编码

     List<UserInfo> list=GetUserS.GetUserList(11);
String json=JSON.toJSONString(list);
HashMap<Object,Object> hs=new HashMap<Object, Object>();
for(int i=0;i<10;i++)
{

    

    • 

  • 进程 vs. 线程
hongtoushizi
线程linux进程

    我们介绍了多进程和多线程，这是实现多任务最常用的两种方式。现在，我们来讨论一下这两种方式的优缺点。
首先，要实现多任务，通常我们会设计Master-Worker模式，Master负责分配任务，Worker负责执行任务，因此，多任务环境下，通常是一个Master，多个Worker。
如果用多进程实现Master-Worker，主进程就是Master，其他进程就是Worker。
如果用多线程实现
    

    • 

  • Linux定时Job：crontab -e 与 /etc/crontab 的区别
Josh_Persistence
linuxcrontab

    一、linux中的crotab中的指定的时间只有5个部分：* * * * *
分别表示：分钟，小时，日，月，星期，具体说来：
第一段 代表分钟 0—59
第二段 代表小时 0—23
第三段 代表日期 1—31
第四段 代表月份 1—12
第五段 代表星期几，0代表星期日 0—6
 
如：
*/1 * * * *   每分钟执行一次。
* 
    

    • 

  • KMP算法详解
hm4123660
数据结构C++算法字符串KMP

         字符串模式匹配我们相信大家都有遇过，然而我们也习惯用简单匹配法（即Brute-Force算法)，其基本思路就是一个个逐一对比下去，这也是我们大家熟知的方法，然而这种算法的效率并不高，但利于理解。
 
    假设主串s="ababcabcacbab",模式串为t="
    

    • 

  • 枚举类型的单例模式
zhb8015
单例模式

    E.编写一个包含单个元素的枚举类型[极推荐]。代码如下：
public enum MaYun {himself; //定义一个枚举的元素，就代表MaYun的一个实例private String anotherField;MaYun() {//MaYun诞生要做的事情//这个方法也可以去掉。将构造时候需要做的事情放在instance赋值的时候：/** himself = MaYun() {*
    

    • 

  • Kafka+Storm+HDFS
ssydxa219
storm

    cd /myhome/usr/stormbin/storm nimbus &amp;bin/storm supervisor &amp;bin/storm ui &amp;Kafka+Storm+HDFS整合实践kafka_2.9.2-0.8.1.1.tgzapache-storm-0.9.2-incubating.tar.gzKafka安装配置我们使用3台机器搭建Kafk
    

    • 

  • Java获取本地服务器的IP
中华好儿孙
javaWeb获取服务器ip地址

    
System.out.println("getRequestURL:"+request.getRequestURL());
System.out.println("getLocalAddr:"+request.getLocalAddr());
System.out.println("getLocalPort:&quo
    

    •