手把手教你23种设计模式

相关知识

简单工厂模式（不属于GoF 23 种设计模式）

工厂方法模式

抽象工厂模式

单例模式

原型模式

建造者模式

代理模式

门面模式（外观模式）

装饰器模式

享元模式

组合模式（整体-部分模式） 【透明式】【 安全式】

适配器模式 【类适配器】 【对象适配器】

桥接模式

模板方法模式

策略模式

责任链模式（职责链模式）

迭代器模式

命令模式

状态模式

备忘录模式（快照模式）

中介者模式（调停模式）

解释器模式

访问者模式

观察者模式

委派模式（不属于GoF 23 种设计模式）

学习设计模式前，强烈建议先学习软件设计七大原则（https://blog.csdn.net/samllwi...）

相关知识

《设计模式：可复用面向对象软件的基础》（Design Patterns: Elements of Reusable Object-Oriented Software）一书有4位作者，这 4 位作者在软件开发领域里也以他们的“四人组”（Gang of Four，GoF）匿名著称。

23种设计模式按照目的分类：创建型模式、结构型模式和行为型模式

23种设计模式按照作用范围分类：类模式和对象型模式

设计模式分类如下表：

范围\目的 创建型模式 结构型模式 行为型模式
类模式 工厂方法（Factory Method）模式 （类）适配器（Adapter）模式 模板方法（TemplateMethod）模式
解释器（Interpreter）模式
对象模式 单例（Singleton）模式
原型（Prototype）模式
抽象工厂（AbstractFactory）模式
建造者（Builder）模式		 代理（Proxy）模式
（对象）适配器（Adapter）模式
桥接（Bridge）模式
装饰（Decorator）模式
外观（Facade）模式
享元（Flyweight）模式
组合（Composite）模式		 策略（Strategy）模式
命令（Command）模式
职责链（Chain of Responsibility）模式
状态（State）模式
观察者（Observer）模式
中介者（Mediator）模式
迭代器（Iterator）模式
访问者（Visitor）模式
备忘录（Memento）模式

把设计模式英文也写上的原因是到时候看源码后缀，可以看出使用了什么设计模式

简单工厂模式（不属于GoF 23 种设计模式）

含义：复杂对象不由用户直接创建，用工厂类进行创建

示例：

小米可以生产手机和电脑，都由工厂产生

public interface IProduct {
    void show();
}

public class MiComputer implements IProduct {
    public void show() {
        System.out.println("小米电脑");
    }
}

public class MiPhone implements IProduct {
    public void show() {
        System.out.println("小米手机");
    }
}

public class MiFactory {
    public static IProduct create(String type){
        if ("phone".equals(type)){
            return new MiPhone();
        }else if ("computer".equals(type)){
            return new MiComputer();
        }else {
            return null;
        }
    }
}

public class TestMain {
    public static void main(String[] args) {
        IProduct miPhone = MiFactory.create("phone");
        miPhone.show();
        IProduct miComputer= MiFactory.create("computer");
        miComputer.show();
    }
}

类图：

手把手教你23种设计模式_第1张图片

工厂方法模式

含义：”工厂方法模式“是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。

示例：

小米手机工厂生产手机，小米电脑工厂生产电脑

public interface IProduct {
    void show();
}

public class MiComputer implements IProduct {
    public void show() {
        System.out.println("小米电脑");
    }
}

public class MiPhone implements IProduct {
    public void show() {
        System.out.println("小米手机");
    }
}

public interface IFactory {
    IProduct create();
}

public class MiComputerFactory implements IFactory {
    public IProduct create() {
        return new MiComputer();
    }
}

public class MiPhoneFactory implements IFactory  {
    public IProduct create(){
       return new MiPhone();
    }
}

public class TestMain {
    public static void main(String[] args) {
        IProduct miPhone = new MiPhoneFactory().create();
        miPhone.show();
        IProduct miComputer = new MiComputerFactory().create();
        miComputer.show();
    }
}

类图：

手把手教你23种设计模式_第2张图片

抽象工厂模式

含义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。一个工厂可以同时生产多种商品

示例：

小米工厂可以生产手机和电脑；华为工厂也可以生产手机和电脑

public interface IProduct {
    void show();
}

public class HuaWeiComputer implements IProduct {
    public void show() {
        System.out.println("华为电脑");
    }
}

public class HuaWeiPhone implements IProduct {
    public void show() {
        System.out.println("华为手机");
    }
}

public class MiComputer implements IProduct {
    public void show() {
        System.out.println("小米电脑");
    }
}

public class MiPhone implements IProduct {
    public void show() {
        System.out.println("小米手机");
    }
}

public interface IFactory {
    IProduct createPhone();
    IProduct createComputer();
}

public class HuaWeiFactory implements IFactory {
    public IProduct createPhone() {
        return new HuaWeiPhone();
    }
    public IProduct createComputer() {
        return new HuaWeiComputer();
    }
}

public class MiFactory implements IFactory {
    public IProduct createPhone() {
        return new MiPhone();
    }
    public IProduct createComputer() {
        return new MiComputer();
    }
}

public class TestMain {
    public static void main(String[] args) {
        MiFactory miFactory = new MiFactory();
        IProduct miPhone = miFactory.createPhone();
        IProduct miComputer = miFactory.createComputer();
        miPhone.show();
        miComputer.show();
        HuaWeiFactory huaWeiFactory = new HuaWeiFactory();
        IProduct huaweiPhone = huaWeiFactory.createPhone();
        IProduct huaweiComputer = huaWeiFactory.createComputer();
        huaweiPhone.show();
        huaweiComputer.show();
    }
}

类图：

手把手教你23种设计模式_第3张图片

单例模式

含义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式

单例模式技能要求：idea下要会多线程调试，控制每个线程的执行顺序

饿汉式

含义：类加载时进行实例化，没有线程安全问题。未使用的类也会占用内存空间

示例：【推荐】

public class HungrySingleton {
    private final static HungrySingleton INSTANCE = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        return INSTANCE;
    }
}

懒汉式

含义：类加载时不会进行实例化，未使用的类不会占用内存空间

示例：

写法1：该写法会有线程安全问题，多个请求会同时进入”if (instance == null)“，并发时会产生多个示例，这也是要了解idea多线程调试。

public class LazySingleton1 {
    private  static LazySingleton1 instance;

    private LazySingleton1() {
    }

    public static LazySingleton1 getInstance() {
        if (instance == null) {
            instance = new LazySingleton1();
        }
        return instance;
    }
}

写法2：加锁，不会有线程安全问题，但会影响效率，每个请求都得进行排队

public class LazySingleton2 {
    private  static LazySingleton2 instance;

    private LazySingleton2() {
    }

    public static synchronized LazySingleton2 getInstance() {
        if (instance == null) {
            instance = new LazySingleton2();
        }
        return instance;
    }
}

写法3：将锁移到内部，可以提高效率，但是还有线程安全问题

public class LazySingleton3 {
    private  static LazySingleton3 instance;

    private LazySingleton3() {
    }

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

写法4：双重检查锁，不仅提高效率，也避免了线程安全问题【推荐】

public class LazySingleton4 {
    private static volatile LazySingleton4 instance;

    private LazySingleton4() {
    }

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

静态内部类方式

含义：静态内部类在加载时不会进行实例化，调用getInstance()时才会进行实例化。不会占用内存，也不会有线程安全问题【推荐】

示例：

public class StaticInnerSingleton {
    private StaticInnerSingleton() {
    }

    public static StaticInnerSingleton getInstance() {
        return InnerSingletonHolder.INSTANCE;
    }

    private static class InnerSingletonHolder {
        private static final StaticInnerSingleton INSTANCE = new StaticInnerSingleton();
    }
}

枚举方式

含义：不管何种单例模式，会有反射创建新实例的情况，但枚举对象有校验不能通过构造方法创建实例【推荐】

示例：

静态内部类通过反射会创建新实例

public class TestMain {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        StaticInnerSingleton instance = StaticInnerSingleton.getInstance();
        System.out.println(instance);
        Class clazz = StaticInnerSingleton.class;
        Constructor constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(true);
        StaticInnerSingleton staticInnerSingleton = constructor.newInstance();
        System.out.println(staticInnerSingleton);
    }
}

结果：

手把手教你23种设计模式_第4张图片

枚举单例

public enum EnumSingleton {
    INSTANCE;

    public static EnumSingleton getInstance() {
        return INSTANCE;
    }
}

public class TestMain {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        EnumSingleton instance = EnumSingleton.getInstance();
        System.out.println(instance);
        Constructor declaredConstructor = EnumSingleton.class.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        EnumSingleton enumSingleton = declaredConstructor.newInstance();
        System.out.println(enumSingleton);
    }
}

结果：

手把手教你23种设计模式_第5张图片

容器方式

含义：使用时才去创建实例，不会浪费内存，无线程安全问题

示例：

public class ContainerSingleton {
    private ContainerSingleton() {

    }

    private static Map container = new HashMap<>();

    public static Object getInstance(String className) {
        if (container.get(className) == null) {
            synchronized (ContainerSingleton.class) {
                if (container.get(className) == null) {
                    Object instance = null;
                    try {
                        instance = Class.forName(className).newInstance();
                    } catch (InstantiationException e) {
                        e.printStackTrace();
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }
                    container.put(className, instance);
                }
            }
        }
        return container.get(className);
    }
}

序列化方式

含义：将实例存储为文件后，重新从文件读取会重新创建一个对象，包含”readResolve“方法读取时就不会重新创建对象

示例：

未添加”readResolve“方法时

public class SerializeSingleton implements Serializable {
    private final static SerializeSingleton INSTANCE = new SerializeSingleton();

    private SerializeSingleton() {
    }

    public static SerializeSingleton getInstance() {
        return INSTANCE;
    }
}

public class TestMain {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        SerializeSingleton instance = SerializeSingleton.getInstance();
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("SerializeSingleton.obj"));
        objectOutputStream.writeObject(instance);
        objectOutputStream.flush();
        objectOutputStream.close();
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("SerializeSingleton.obj"));
        Object o = objectInputStream.readObject();
        objectInputStream.close();
        System.out.println(instance == o);
    }
}

结果：

手把手教你23种设计模式_第6张图片

添加”readResolve“方法时

public class SerializeSingleton implements Serializable {
    private final static SerializeSingleton INSTANCE = new SerializeSingleton();

    private SerializeSingleton() {
    }

    public static SerializeSingleton getInstance() {
        return INSTANCE;
    }

    private Object readResolve(){
        return INSTANCE;
    }
}

结果：

手把手教你23种设计模式_第7张图片

原型模式

含义：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。

原型模式的克隆分为浅克隆和深克隆。

浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。

深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

示例：

每个人都有手机，克隆人的时候手机是独立的，不会去引用同一个手机

public class Phone implements Serializable {
}

@Data
public class PerSonPrototype implements Serializable {
    private String name;
    private Integer age;
    private Phone phone;

    /**
     * 深克隆
     * @return
     */
    public PerSonPrototype deepClone(){
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream outputStream = new ObjectOutputStream(bos);
            outputStream.writeObject(this);
            ObjectInputStream inputStream = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
            Object o = inputStream.readObject();
            return (PerSonPrototype) o;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 浅克隆
     * @return
     */
    public PerSonPrototype shallowClone(){
        PerSonPrototype perSonPrototype = new PerSonPrototype();
        perSonPrototype.setName(this.getName());
        perSonPrototype.setAge(this.getAge());
        perSonPrototype.setPhone(this.getPhone());
        return perSonPrototype;
    }
}

public class TestMain {
    public static void main(String[] args) {
        PerSonPrototype perSonPrototype = new PerSonPrototype();
        perSonPrototype.setName("zhang");
        perSonPrototype.setAge(10);
        perSonPrototype.setPhone(new Phone());
        PerSonPrototype deepCloneObj = perSonPrototype.deepClone();
        PerSonPrototype shallowCloneObj = perSonPrototype.shallowClone();
        System.out.println(perSonPrototype.getPhone() == deepCloneObj.getPhone());
        System.out.println(perSonPrototype.getPhone() == shallowCloneObj.getPhone());
    }
}

结果：

手把手教你23种设计模式_第8张图片

类图：

手把手教你23种设计模式_第9张图片

建造者模式

含义：将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示

mybatis-plus中可以通过lambada表达式构建查询语句，就是使用了建造者模式

示例：

汽车工厂通过工程师来组装汽车

/**
 * 汽车
 *
 * @author lipangpang
 * @date 2021/12/13
 * @description
 */
@Data
public class Car {
    /**
     * 轮胎
     */
    private String tyre;
    /**
     * 发动机
     */
    private String engine;
    /**
     * 颜色
     */
    private String color;

}

/**
 * 工程师
 *
 * @author lipangpang
 * @date 2021/12/13
 * @description
 */
public abstract class IBuilder {
    protected Car car = new Car();

    public abstract void buildTyre();

    public abstract void buildEngine();

    public abstract void buildColor();

    public Car getCar() {
        return car;
    }
}

/**
 * @author lipangpang
 * @date 2021/12/13
 * @description
 */
public class Builder extends IBuilder {

    @Override
    public void buildTyre() {
        car.setTyre("玛吉斯轮胎");
    }

    @Override
    public void buildEngine() {
        car.setEngine("蓝鲸发动机");
    }

    @Override
    public void buildColor() {
        car.setColor("红色");
    }
}

/**
 * 汽车工厂
 *
 * @author lipangpang
 * @date 2021/12/13
 * @description
 */
public class CarFactory {
    private IBuilder builder;

    public CarFactory(IBuilder builder) {
        this.builder = builder;
    }

    public Car build(){
        builder.buildTyre();
        builder.buildEngine();
        builder.buildColor();
        return builder.getCar();
    }
}

public class TestMain {
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory(new Builder());
        Car car = carFactory.build();
        System.out.println(car);
    }
}

类图：

手把手教你23种设计模式_第10张图片

代理模式

含义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作

为访问对象和目标对象之间的中介。

根据代理的创建时期，代理模式分为静态代理和动态代理。

静态：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。

动态：在程序运行时，运用反射机制动态创建而成

示例：

静态代理

人通过中介购买房子，中介先列出房子相关信息，人购买房子，中介收取中介费

public interface IPerson {
    void buy();
}

public class Person implements IPerson {
    @Override
    public void buy() {
        System.out.println("顾客买房子");
    }
}

public class Proxy implements IPerson{

    private IPerson person;

    public Proxy(IPerson person) {
        this.person = person;
    }

    @Override
    public void buy() {
        before();
        person.buy();
        after();
    }

    public void before(){
        System.out.println("列出房子相关信息");
    }

    public void after(){
        System.out.println("交易成功，收取中介费");
    }
}

public class TestMain {
    public static void main(String[] args) {
        IPerson person = new Person();
        Proxy proxy = new Proxy(person);
        proxy.buy();
    }
}

类图：

手把手教你23种设计模式_第11张图片

实例：

动态代理实现

public interface IPerson {
    void buy();
}

public class Person implements IPerson {
    @Override
    public void buy() {
        System.out.println("顾客买房子");
    }
}

public class ProxyInvocationHandler implements InvocationHandler {
    private Object target;

    public ProxyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("列出房子相关信息");
        Object result = method.invoke(target, args);
        System.out.println("交易成功，收取中介费");
        return result;
    }
}

public class TestMain {
    public static void main(String[] args) {
        IPerson person = new Person();
        ProxyInvocationHandler handler = new ProxyInvocationHandler(person);
        IPerson proxyInstance = (IPerson) Proxy.newProxyInstance(person.getClass().getClassLoader(),                  person.getClass().getInterfaces(), handler);
        proxyInstance.buy();
    }
}

类图：

手把手教你23种设计模式_第12张图片

门面模式（外观模式）

含义：门面模式也叫外观模式，通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。

门店模式是一种静态的代理模式。

示例：

用户再商城购买商品，会在订单系统先创建订单，然后库存系统扣减库存，再从物流系统发货

public class OrderSystem {
    public void createOrder(){
        System.out.println("订单系统先创建订单");
    }
}

public class StockSystem {
    public void decreaseStock(){
        System.out.println("库存系统扣减库存");
    }
}

public class LogisticsSystem {
    public void addSalesVolume(){
        System.out.println("物流系统发货");
    }
}

public class MallFacade {
    private OrderSystem orderSystem = new OrderSystem();
    private StockSystem stockSystem = new StockSystem();
    private LogisticsSystem logisticsSystem = new LogisticsSystem();

    public void buyGoods(){
        orderSystem.createOrder();;
        stockSystem.decreaseStock();
        logisticsSystem.addSalesVolume();
    }
}

public class TestMain {
    public static void main(String[] args) {
        MallFacade mallFacade = new MallFacade();
        mallFacade.buyGoods();
    }
}

类图：

手把手教你23种设计模式_第13张图片

装饰器模式

含义：在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式。

java中流的封装是一种装饰器模式的实现，如下

BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(""));

示例：

水果蛋糕，在纯蛋糕的基础上可以增加芒果、草莓和樱桃等。

/**
 * 蛋糕接口
 * @author lipangpang
 * @date 2021/12/15
 * @description
 */
public interface ICake {
    String getInfo();
}

/**
 * 纯蛋糕
 * @author lipangpang
 * @date 2021/12/15
 * @description
 */
public class BaseCake implements ICake {
    @Override
    public String getInfo() {
        return "纯蛋糕";
    }
}

/**
 * 水果装饰器
 * @author lipangpang
 * @date 2021/12/15
 * @description
 */
public class FruitDecorator implements ICake {
    private ICake iCake;

    public FruitDecorator(ICake iCake) {
        this.iCake = iCake;
    }

    @Override
    public String getInfo() {
        return this.iCake.getInfo();
    }
}

/**
 * 芒果装饰器
 * @author lipangpang
 * @date 2021/12/15
 * @description
 */
public class MangoDecorator extends FruitDecorator {
    public MangoDecorator(ICake iCake) {
        super(iCake);
    }

    @Override
    public String getInfo() {
        return super.getInfo() + " + 芒果";
    }
}

/**
 * 草莓装饰器
 *
 * @author lipangpang
 * @date 2021/12/15
 * @description
 */
public class StrawberryDecorator extends FruitDecorator {
    public StrawberryDecorator(ICake iCake) {
        super(iCake);
    }

    @Override
    public String getInfo() {
        return super.getInfo() + " + 草莓";
    }
}

/**
 * 樱桃装饰器
 * @author lipangpang
 * @date 2021/12/15
 * @description
 */
public class CherryDecorator extends FruitDecorator {
    public CherryDecorator(ICake iCake) {
        super(iCake);
    }

    @Override
    public String getInfo() {
        return super.getInfo() + " + 樱桃";
    }
}

public class TestMain {
    public static void main(String[] args)  {
        ICake baseCake = new BaseCake();
        System.out.println(baseCake.getInfo());
        MangoDecorator mangoDecorator = new MangoDecorator(baseCake);
        System.out.println(mangoDecorator.getInfo());
        StrawberryDecorator strawberryDecorator = new StrawberryDecorator(mangoDecorator);
        System.out.println(strawberryDecorator.getInfo());
        CherryDecorator cherryDecorator = new CherryDecorator(strawberryDecorator);
        System.out.println(cherryDecorator.getInfo());
    }
}

结果：

手把手教你23种设计模式_第14张图片

类图：

手把手教你23种设计模式_第15张图片

享元模式

含义：运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似

类的开销，从而提高系统资源的利用率。

享元模式包含的对象有两种状态：内部状态和外部状态；

内部状态指对象共享出来的信息，存储在享元信息内部，并且不回随环境的改变而改变；

外部状态指对象得以依赖的一个标记，随环境的改变而改变，不可共享。

示例：

火车站现在都有投放按摩椅，椅子是固定的，去消费的人不是固定的

/**
 * 游客
 *
 * @author lipangpang
 * @date 2021/12/16
 * @description
 */
public class Person {
    /**
     * 游客姓名
     */
    private String name;


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

    public String buyService() {
        return name + "花钱购买了";
    }
}

/**
 * 按摩椅接口
 *
 * @author lipangpang
 * @date 2021/12/16
 * @description
 */
public interface IChair {
    /**
     * 获取按摩椅信息
     *
     * @return
     */
    String getInfo(Person person);
}

/**
 * 按摩椅
 *
 * @author lipangpang
 * @date 2021/12/16
 * @description
 */
public class Chair implements IChair {

    /**
     * 编号
     */
    private String chairNo;

    public Chair(String chairNo) {
        this.chairNo = chairNo;
    }

    @Override
    public String getInfo(Person person) {
        return person.buyService() + "按摩椅" + chairNo + "的服务";
    }
}

/**
 * 按摩椅工厂
 *
 * @author lipangpang
 * @date 2021/12/16
 * @description
 */
public class ChairFactory {
    private Map chairNo2Chair = new HashMap<>();

    public ChairFactory() {
        for (int i = 1; i <= 5; i++) {
            String chairNo = "A00" + i;
            chairNo2Chair.put(chairNo, new Chair(chairNo));
        }
    }

    public IChair getChair(String chairNo) {
        return chairNo2Chair.get(chairNo);
    }
}

public class TestMain {
    public static void main(String[] args) {
        ChairFactory chairFactory = new ChairFactory();
        IChair chair1 = chairFactory.getChair("A001");
        IChair chair11 = chairFactory.getChair("A001");
        IChair chair2 = chairFactory.getChair("A002");
        System.out.println(chair1.getInfo(new Person("zhang")));
        System.out.println(chair11.getInfo(new Person("li")));
        System.out.println(chair2.getInfo(new Person("wang")));
    }
}

类图：

手把手教你23种设计模式_第16张图片

组合模式（整体-部分模式）

含义：又叫作整体-部分（Part-Whole）模式，它是一种将对象组合成树状的层次结构的模式，用来表示“整体-部分”的关系，使用户

对单个对象和组合对象具有一致的访问性。将对象组合到树形结构中，有根节点、树枝节点和叶子节点，树形结构图如下。

手把手教你23种设计模式_第17张图片

组合模式分为透明式的组合模式和安全式的组合模式。

透明式：

示例：文件系统，包含文件和文件夹。文件和文件都继承同一个抽象接口，抽象接口包含所有方法。

/**
 * 安全模式-文件系统-目录
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public abstract class Directory {
    protected String name;

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

    public void add(Directory directory) {
        throw new UnsupportedOperationException("不支持增加操作");
    }

    public void remove(Directory directory) {
        throw new UnsupportedOperationException("不支持移出操作");
    }

    public abstract void print();

}

/**
 * 安全模式-文件系统-文件
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public class File extends Directory {
    public File(String name) {
        super(name);
    }

    @Override
    public void print() {
        System.out.println("    文件 " + this.name);
    }
}

/**
 * 安全模式-文件系统-文件夹
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public class Folder extends Directory {
    private List items = new ArrayList<>();

    public Folder(String name) {
        super(name);
    }

    @Override
    public void print() {
        System.out.println("文件夹 " + this.name + "==>");
        for (Directory item : items) {
            item.print();
        }
    }

    @Override
    public void add(Directory directory) {
        items.add(directory);
    }

    @Override
    public void remove(Directory directory) {
        items.remove(directory);
    }
}

public class TestMain {
    public static void main(String[] args) {
        Directory root = new Folder("C盘");
        File idea = new File("idea开发工具");
        root.add(idea);
        Directory musicTool = new Folder("音乐工具文件夹");
        File kugouMusic = new File("酷狗音乐软件");
        File qqMusic = new File("QQ音乐软件");
        musicTool.add(kugouMusic);
        musicTool.add(qqMusic);
        root.add(musicTool);
        root.print();
    }
}

结果：

手把手教你23种设计模式_第18张图片

类图：

手把手教你23种设计模式_第19张图片

安全式：

示例：文件系统，包含文件和文件夹。文件和文件都继承同一个抽象接口，抽象接口只包含公共方法。

/**
 * 安全模式-文件系统-目录
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public abstract class Directory {
    protected String name;

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


    public abstract void print();

}

/**
 * 安全模式-文件系统-文件
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public class File extends Directory {
    public File(String name) {
        super(name);
    }

    @Override
    public void print() {
        System.out.println("===>文件 " + this.name);
    }
}

/**
 * 安全模式-文件系统-文件夹
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public class Folder extends Directory {
    private List items = new ArrayList<>();

    public Folder(String name) {
        super(name);
    }


    @Override
    public void print() {
        System.out.println("文件夹 " + this.name);
        for (Directory item : items) {
            item.print();
        }
    }

    public void add(Directory directory) {
        items.add(directory);
    }

    public void remove(Directory directory) {
        items.remove(directory);
    }
}

public class TestMain {
    public static void main(String[] args) {
        Folder root = new Folder("C盘");
        File idea = new File("idea开发工具");
        root.add(idea);
        Folder musicTool = new Folder("音乐工具文件夹");
        File kugouMusic = new File("酷狗音乐软件");
        File qqMusic = new File("QQ音乐软件");
        musicTool.add(kugouMusic);
        musicTool.add(qqMusic);
        root.add(musicTool);
        root.print();
    }
}

结果：

手把手教你23种设计模式_第20张图片

类图：

手把手教你23种设计模式_第21张图片

适配器模式

含义：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。适配器模式分为类结构型模式和对象结构型模式两种，前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少些。

适配器模式（Adapter）包含以下主要角色。

  1. 目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口。
  2. 适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口。

  3. 适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式

    访问适配者。

类适配器：

示例：

电源适配器，可以将220v交流电转换成5v或者10v的直流电

/**
 * 直流电目标
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public interface IDirectTarget {
    /**
     * 获取5v直流电
     *
     * @return
     */
    int getDirect5v();

    /**
     * 获取10v直流电
     *
     * @return
     */
    int getDirect10v();
}

/**
 * 交流电220v适配者
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public class AC220Adaptee {

    /**
     * 获取220v交流电
     *
     * @return
     */
    public int getAC220v() {
        return 220;
    }
}

/**
 * 电源适配器
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public class PowerAdapter extends AC220Adaptee implements IDirectTarget {
    @Override
    public int getDirect5v() {
        return getAC220v() / 44;
    }

    @Override
    public int getDirect10v() {
        return getAC220v() / 22;
    }
}

public class TestMain {
    public static void main(String[] args) {
        PowerAdapter powerAdapter = new PowerAdapter();
        System.out.println(powerAdapter.getDirect5v());
        System.out.println(powerAdapter.getDirect10v());
    }
}

类图：

手把手教你23种设计模式_第22张图片

对象适配器：

示例：

电源适配器，可以将220v交流电转换成5v或者10v的直流电

/**
 * 直流电目标
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public interface IDirectTarget {
    /**
     * 获取5v直流电
     *
     * @return
     */
    int getDirect5v();

    /**
     * 获取10v直流电
     *
     * @return
     */
    int getDirect10v();
}

/**
 * 交流电220v适配者
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public class AC220Adaptee {

    /**
     * 获取220v交流电
     *
     * @return
     */
    public int getAC220v() {
        return 220;
    }
}

/**
 * 电源适配器
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public class PowerAdapter implements IDirectTarget {

    private AC220Adaptee ac220Adaptee;

    public PowerAdapter(AC220Adaptee ac220Adaptee) {
        this.ac220Adaptee = ac220Adaptee;
    }

    @Override
    public int getDirect5v() {
        return ac220Adaptee.getAC220v() / 44;
    }

    @Override
    public int getDirect10v() {
        return ac220Adaptee.getAC220v() / 22;
    }
}

public class TestMain {
    public static void main(String[] args) {
        PowerAdapter powerAdapter = new PowerAdapter(new AC220Adaptee());
        System.out.println(powerAdapter.getDirect5v());
        System.out.println(powerAdapter.getDirect10v());
    }
}

类图：

手把手教你23种设计模式_第23张图片

桥接模式

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

度。

桥接（Bridge）模式包含以下主要角色。

  1. 抽象化（Abstraction）角色：定义抽象类，并包含一个对实现化对象的引用。

  2. 扩展抽象化（Refined Abstraction）角色：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务

    方法。

  3. 实现化（Implementor）角色：定义实现化角色的接口，供扩展抽象化角色调用。
  4. 具体实现化（Concrete Implementor）角色：给出实现化角色接口的具体实现。

示例：

汽车有红色和白色，摩托车有红色和白色，当要其中一种对象时，不会创建四种对象类，而是通过组合的方式，创建两种对象类。

/**
 * 颜色接口
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public interface IColor {
    String getColor();
}

public class Red implements IColor {
    @Override
    public String getColor() {
        return "红色";
    }
}

public class White implements IColor {
    @Override
    public String getColor() {
        return "白色";
    }
}

/**
 * 交通工具桥接类
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public abstract class IVehicle {
    protected IColor color;

    public IVehicle(IColor color) {
        this.color = color;
    }

    public abstract void printInfo();
}

/**
 * 摩托车
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public class Motorcycle extends IVehicle {
    public Motorcycle(IColor color) {
        super(color);
    }

    @Override
    public void printInfo() {
        System.out.println("摩托" + color.getColor());
    }
}

/**
 * 汽车
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public class Car extends IVehicle {
    public Car(IColor color) {
        super(color);
    }

    @Override
    public void printInfo() {
        System.out.println("汽车" + color.getColor());
    }
}

public class TestMain {
    public static void main(String[] args) {
        Car car = new Car(new White());
        car.printInfo();
        car = new Car(new Red());
        car.printInfo();
    }
}

类图：

手把手教你23种设计模式_第24张图片

模板方法模式

含义：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特

定步骤。

模板方法模式包含以下角色。

  1. 抽象模板

    1. 模板方法：定义了算法的骨架，按某种顺序调用其包含的基本方法。

    2. 基本方法：是整个算法中的一个步骤，包含以下几种类型。

      1. 抽象方法：在抽象类中声明，由具体子类实现。
      2. 具体方法：在抽象类中已经实现，在具体子类中可以继承或重写它。
      3. 钩子方法：在抽象类中已经实现，包括用于判断的逻辑方法和需要子类重写的空方法两种。
  2. 具体实现

示例：

用户在手机上购买商品流程，先挑选商品，创建订单，支付，然后根据需要时上门自提还是骑手配送。

/**
 * 购物模板类
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public abstract class ShoppingTemplate {
    protected abstract String searchProduct();

    final String createOrder() {
        return "创建订单";
    }

    final String payOrder() {
        return "支付订单";
    }

    /**
     * 钩子方法，用于调整业务流程
     *
     * @return
     */
    protected abstract boolean isLogistics();

    final String selfMention() {
        return "到门店自提";
    }

    final String Logistics() {
        return "骑手配送上门";
    }

    public void shopping() {
        String result = searchProduct() + ">" + createOrder() + ">" + payOrder();
        if (isLogistics()) {
            result += ">" + Logistics();
        } else {
            result += ">" + selfMention();
        }
        System.out.println(result);
    }
}

/**
 * 消费者购物类
 *
 * @author lipangpang
 * @date 2021/12/18
 * @description
 */
public class CustomerShopping extends ShoppingTemplate {
    private String productName;
    private boolean isLogistics;

    public CustomerShopping(String productName, boolean isLogistics) {
        this.productName = productName;
        this.isLogistics = isLogistics;
    }

    @Override
    protected String searchProduct() {
        return this.productName;
    }

    @Override
    protected boolean isLogistics() {
        return this.isLogistics;
    }
}

public class TestMain {
    public static void main(String[] args) {
        System.out.println("顾客1订单信息===");
        CustomerShopping customerShopping1 = new CustomerShopping("苹果",true);
        customerShopping1.shopping();
        System.out.println("顾客2订单信息===");
        CustomerShopping customerShopping2 = new CustomerShopping("香蕉",false);
        customerShopping2.shopping();
    }
}

结果：

手把手教你23种设计模式_第25张图片

类图：

手把手教你23种设计模式_第26张图片

策略模式

含义：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。

策略模式结构如下。

  1. 抽象策略类
  2. 具体策略类
  3. 环境类

示例：每个人都周末都有不同的安排，比如健身、看电影和学习等。

/**
 * 活动抽象策略类
 *
 * @author lipangpang
 * @date 2021/12/22
 * @description
 */
public interface IActivity {
    /**
     * 策略方法
     */
    void execute();
}

public class BodyBuildingActivity implements IActivity {
    @Override
    public void execute() {
        System.out.println("周末健身");
    }
}

public class MovieActivity implements IActivity {
    @Override
    public void execute() {
        System.out.println("周末看电影");
    }
}

public class StudyActivity implements IActivity {
    @Override
    public void execute() {
        System.out.println("周末学习");
    }
}

public class TestMain {
    public static void main(String[] args) {
        StrategyContext strategyContext = new StrategyContext(new MovieActivity());
        strategyContext.executeStrategy();
    }
}

结果：

周末看电影

类图：

手把手教你23种设计模式_第27张图片

责任链模式（职责链模式）

含义：为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条

链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

责任链模式结构如下。

  1. 抽象处理者
  2. 具体处理者
  3. 客户类

示例：去店铺买东西，导购员有打9折权限，储备店长有打8折权限，店长有打7折权限。

/**
 * 员工抽象类
 *
 * @author lipangpang
 * @date 2021/12/22
 * @description
 */
public abstract class Handler {
    /**
     * 下一执行人
     */
    private Handler next;

    public Handler getNext() {
        return next;
    }

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

    /**
     * 处理请求方法
     *
     * @param discount
     */
    abstract void handlerDiscount(Integer discount);
}

/**
 * 导购员
 *
 * @author lipangpang
 * @date 2021/12/22
 * @description
 */
public class ShoppingGuide extends Handler {
    @Override
    void handlerDiscount(Integer discount) {
        if (discount >= 9) {
            System.out.println("导购员打9折");
        } else {
            if (this.getNext() == null) {
                System.out.println("导购员不能进行打" + discount + "折");
            } else {
                this.getNext().handlerDiscount(discount);
            }
        }
    }
}

/**
 * 储备店长
 *
 * @author lipangpang
 * @date 2021/12/22
 * @description
 */
public class ReserverManager extends Handler {
    @Override
    void handlerDiscount(Integer discount) {
        if (discount >= 8) {
            System.out.println("储备店长打8折");
        } else {
            if (this.getNext() == null) {
                System.out.println("储备店长不能进行打" + discount + "折");
            } else {
                this.getNext().handlerDiscount(discount);
            }
        }
    }
}

/**
 * 店长
 *
 * @author lipangpang
 * @date 2021/12/22
 * @description
 */
public class Manager extends Handler {
    @Override
    void handlerDiscount(Integer discount) {
        if (discount >= 7) {
            System.out.println("店长打7折");
        } else {
            if (this.getNext() == null) {
                System.out.println("店长不能进行打" + discount + "折");
            } else {
                this.getNext().handlerDiscount(discount);
            }
        }
    }
}

public class TestMain {
    public static void main(String[] args) {
        ShoppingGuide shoppingGuide = new ShoppingGuide();
        ReserverManager reserverManager = new ReserverManager();
        Manager manager = new Manager();
        shoppingGuide.setNext(reserverManager);
        reserverManager.setNext(manager);
        shoppingGuide.handlerDiscount(8);
    }
}

结果：

储备店长打8折

类图：

手把手教你23种设计模式_第28张图片

迭代器模式

含义：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

迭代器模式结构如下。

  1. 抽象聚合角色：义存储、添加、删除聚合对象以及创建迭代器对象的接口。
  2. 具体聚合角色：实现抽象聚合类，返回一个具体迭代器的实例。
  3. 抽象迭代器角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
  4. 具体迭代器角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

示例：实现类似List的功能，可以增加、删除元素，获取迭代器，遍历元素。

/**
 * 抽象集合接口
 * @author lipangpang
 * @date 2021/12/25
 * @description
 */
public interface MyList {
    /**
     * 增加元素
     *
     * @param o
     */
    void add(Object o);

    /**
     * 删除元素
     *
     * @param o
     */
    void remove(Object o);

    /**
     * 获取迭代器
     *
     * @return
     */
    Iterator iterator();
}

/**
 * 抽象聚合实现类
 * @author lipangpang
 * @date 2021/12/25
 * @description
 */
public class MyListImpl implements MyList {
    private List list = new ArrayList<>();
    @Override
    public void add(Object o) {
        list.add(o);
    }

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

    @Override
    public Iterator iterator() {
        return new IteratorImpl(list);
    }
}

/**
 * 迭代器接口
 *
 * @author lipangpang
 * @date 2021/12/25
 * @description
 */
public interface Iterator {
    /**
     * 获取第一个元素
     *
     * @return
     */
    Object first();

    /**
     * 获取下一个元素
     *
     * @return
     */
    Object next();

    /**
     * 是否有下一个元素
     *
     * @return
     */
    boolean hasNext();
}

/**
 * 迭代器实现类
 *
 * @author lipangpang
 * @date 2021/12/25
 * @description
 */
public class IteratorImpl implements Iterator {
    private List list;
    private Integer index = -1;

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

    @Override
    public Object first() {
        index = 0;
        if (list.size() == 0){
            throw new NoSuchElementException("没有元素");
        }
        return list.get(index);
    }

    @Override
    public Object next() {
        if (index == list.size()){
            throw new NoSuchElementException("没有元素");
        }
        return list.get(index);
    }

    @Override
    public boolean hasNext() {
        index++;
        return index < list.size();
    }
}

public class TestMain {
    public static void main(String[] args) {
        MyList myList = new MyListImpl();
        myList.add("a");
        myList.add("b");
        myList.add("c");
        Iterator iterator = myList.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
} 
 
结果：
 
 
a
b
c
 
 
类图：
 
 
手把手教你23种设计模式_第29张图片
 
 
命令模式
 
 
含义：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令
 
 
对象进行储存、传递、调用、增加与管理。
 
 
命令模式结构如下。
 
 
     
  
  1. 抽象命令类（Command）角色：声明执行命令的接口，拥有执行命令的抽象方法 execute()。
    2.  
  
  2. 具体命令类（Concrete Command）角色：是抽象命令类的具体实现类，它拥有接收者对象，并通过调用接收者的功能来完成命令要
    执行的操作。
    3.  
  
  3. 实现者/接收者（Receiver）角色：执行命令功能的相关操作，是具体命令对象业务的真正实现者。
    4.  
  
  4. 调用者/请求者（Invoker）角色：是请求的发送者，它通常拥有很多的命令对象，并通过访问命令对象来执行相关请求，它不直接访
    问接收者。
    5.  
 
 
 
示例：每天早上家长叫孩子起床、刷牙
 
 
/**
 * 命令接口
 *
 * @author lipangpang
 * @date 2021/12/25
 * @description
 */
public interface ICommand {
    void execute();
}

/**
 * 起床命令
 *
 * @author lipangpang
 * @date 2021/12/25
 * @description
 */
public class GetUpCommand implements ICommand {
    private ChildrenReceiver childrenReceiver;

    public GetUpCommand(ChildrenReceiver childrenReceiver) {
        this.childrenReceiver = childrenReceiver;
    }

    @Override
    public void execute() {
        childrenReceiver.getUp();
    }
}

/**
 * 刷牙命令
 *
 * @author lipangpang
 * @date 2021/12/25
 * @description
 */
public class BrushTeethCommand implements ICommand {
    private ChildrenReceiver childrenReceiver;

    public BrushTeethCommand(ChildrenReceiver childrenReceiver) {
        this.childrenReceiver = childrenReceiver;
    }

    @Override
    public void execute() {
        childrenReceiver.brushTeeth();
    }
}

/**
 * 孩子接收者
 *
 * @author lipangpang
 * @date 2021/12/25
 * @description
 */
public class ChildrenReceiver {

    public void getUp() {
        System.out.println("起床");
    }

    public void brushTeeth() {
        System.out.println("刷牙");
    }
}

/**
 * 家长调用者
 *
 * @author lipangpang
 * @date 2021/12/25
 * @description
 */
public class ParentInvoker {
    private ICommand command;

    public ParentInvoker() {

    }

    public ICommand getCommand() {
        return command;
    }

    public void setCommand(ICommand command) {
        this.command = command;
    }

    public void call() {
        command.execute();
    }
}

public class TestMain {
    public static void main(String[] args) {
        ChildrenReceiver childrenReceiver = new ChildrenReceiver();
        GetUpCommand getUpCommand = new GetUpCommand(childrenReceiver);
        BrushTeethCommand brushTeethCommand = new BrushTeethCommand(childrenReceiver);
        ParentInvoker parentInvoker = new ParentInvoker();
        parentInvoker.setCommand(getUpCommand);
        parentInvoker.call();
        parentInvoker.setCommand(brushTeethCommand);
        parentInvoker.call();
    }
}
 
 
结果：
 
 
起床
刷牙
 
 
类图：
 
 
手把手教你23种设计模式_第30张图片
 
 
状态模式
 
 
含义：对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。
 
 
状态模式结构如下。
 
 
     
  
  1. 环境类（Context）角色：也称为上下文，它定义了客户端需要的接口，内部维护一个当前状态，并负责具体状态的切换。
    2.  
  
  2. 抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为，可以有一个或多个行为。
    3.  
  
  3. 具体状态（Concrete State）角色：实现抽象状态所对应的行为，并且在需要的情况下进行状态切换。
    4.  
 
 
 
示例：订单支付状态有待支付、已支付和已退款，待支付才能进行支付，已支付才能进行退款。
 
 
/**
 * 抽象状态类
 *
 * @author lipangpang
 * @date 2021/12/26
 * @description
 */
public abstract class State {
    /**
     * 状态名称
     */
    protected String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

/**
 * 待支付状态
 *
 * @author lipangpang
 * @date 2021/12/26
 * @description
 */
public class UnPayState extends State {
    public UnPayState() {
        this.name = "待支付状态";
        System.out.println("当前订单状态：" + this.name);
    }

    /**
     * 支付操作
     *
     * @param orderContext
     */
    public void pay(OrderContext orderContext) {

        orderContext.setState(new PayedState());
    }
}

/**
 * 已支付状态
 *
 * @author lipangpang
 * @date 2021/12/26
 * @description
 */
public class PayedState extends State {
    public PayedState() {
        this.name = "已支付状态";
        System.out.println("当前订单状态：" + this.name);
    }

    /**
     * 退款操作
     *
     * @param orderContext
     */
    public void refund(OrderContext orderContext) {
        orderContext.setState(new RefundedState());
    }
}

/**
 * 已退款状态
 *
 * @author lipangpang
 * @date 2021/12/26
 * @description
 */
public class RefundedState extends State {
    public RefundedState() {
        this.name = "已退款状态";
        System.out.println("当前订单状态：" + this.name);
    }
}

/**
 * 订单环境类
 *
 * @author lipangpang
 * @date 2021/12/26
 * @description
 */
public class OrderContext {
    private State state;

    public OrderContext() {
        this.state = new UnPayState();
    }

    public State getState() {
        return state;
    }

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

    /**
     * 支付操作
     */
    public void pay() {
        System.out.println("去支付");
        if ("待支付状态".equals(state.getName())){
            ((UnPayState)state).pay(this);
        }else {
            System.out.println("待支付状态才能去支付");
        }
    }

    /**
     * 退款操作
     */
    public void refund() {
        System.out.println("去退款");
        if ("已支付状态".equals(state.getName())){
            ((PayedState)state).refund(this);
        }else {
            System.out.println("已支付状态才能去退款");
        }
    }
}

public class TestMain {
    public static void main(String[] args) {
        OrderContext orderContext = new OrderContext();
        orderContext.pay();
        orderContext.refund();
    }
}
 
 
结果：
 
 
当前订单状态：待支付状态
去支付
当前订单状态：已支付状态
去退款
当前订单状态：已退款状态
 
 
类图：
 
 
手把手教你23种设计模式_第31张图片
 
 
备忘录模式（快照模式）
 
 
含义：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要时能将该对象恢复到原先保
 
 
存的状态。
 
 
备忘录模式结构如下。
 
 
     
  
  1. 发起人（Originator）角色：记录当前时刻的内部状态信息，提供创建备忘录和恢复备忘录数据的功能，实现其他业务功能，它可以
    访问备忘录里的所有信息。
    2.  
  
  2. 备忘录（Memento）角色：负责存储发起人的内部状态，在需要的时候提供这些内部状态给发起人。
    3.  
  
  3. 管理者（Caretaker）角色：对备忘录进行管理，提供保存与获取备忘录的功能，但其不能对备忘录的内容进行访问与修改。
    4.  
 
 
 
示例：用户在编辑文档的时候，每次保存都会存储一份当前数据的状态当做备忘录，按下撤销键可以返回上一个状态。
 
 
/**
 * 备忘录数据
 *
 * @author lipangpang
 * @date 2021/12/26
 * @description
 */
public class Memento {
    private String data;

    public String getData() {
        return data;
    }

    public void setData(String data) {
        this.data = data;
    }
}

/**
 * 备忘录管理者
 *
 * @author lipangpang
 * @date 2021/12/26
 * @description
 */
public class Caretaker {
    /**
     * 所有备忘录数据
     */
    private Stack datas = new Stack<>();

    /**
     * 保存备忘录数据
     *
     * @return
     */
    public Memento getData() {
        return datas.pop();
    }

    /**
     * 获取备忘录数据
     *
     * @param memento
     * @return
     */
    public Memento saveData(Memento memento) {
        return datas.push(memento);
    }
}

/**
 * 编辑文档发起者
 *
 * @author lipangpang
 * @date 2021/12/26
 * @description
 */
public class EditOriginator {
    /**
     * 用户当前编辑的文本
     */
    private String text;

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

    /**
     * 创建备忘录数据
     */
    public Memento createMemento() {
        Memento memento = new Memento();
        memento.setData(text);
        return memento;
    }
}

public class TestMain {
    public static void main(String[] args) {
        EditOriginator editOriginator = new EditOriginator();
        Caretaker caretaker = new Caretaker();
        editOriginator.setText("第一次编辑数据");
        caretaker.saveData(editOriginator.createMemento());
        editOriginator.setText("第二次编辑数据");
        System.out.println("当前数据：" + editOriginator.getText());
        editOriginator.setText(caretaker.getData().getData());
        System.out.println("回滚后数据：" + editOriginator.getText());
    }
}
 
 
结果：
 
 
当前数据：第二次编辑数据
回滚后数据：第一次编辑数据
 
 
类图：
 
 
手把手教你23种设计模式_第32张图片
 
 
中介者模式（调停模式）
 
 
含义：定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互
 
 
中介者模式结构如下。
 
 
     
  
  1. 抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
    2.  
  
  2. 具体中介者（Concrete Mediator）角色：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因
    此它依赖于同事角色。
    3.  
  
  3. 抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类
    的公共功能。
    4.  
  
  4. 具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。
    5.  
 
 
 
示例：群聊的时候，只要有一个人发消息，群众的所有人可以接受到消息。
 
 
/**
 * 同事接口
 *
 * @author lipangpang
 * @date 2021/12/27
 * @description
 */
public abstract class IColleague {
    /**
     * 聊天室中介者
     */
    protected IGroupChatMediator groupChatMediator;
    /**
     * 同事姓名
     */
    private String name;
    /**
     * 同事发送的消息
     */
    private String msg;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public IColleague(IGroupChatMediator groupChatMediator, String name) {
        this.groupChatMediator = groupChatMediator;
        this.name = name;
    }

    /**
     * 发送消息
     *
     * @param msg
     */
    abstract void sendMsg(String msg);

    /**
     * 接受消息
     *
     * @param msg
     */
    abstract void receiveMsg(String msg);
}

/**
 * 同事
 *
 * @author lipangpang
 * @date 2021/12/27
 * @description
 */
public class Colleague extends IColleague {
    public Colleague(IGroupChatMediator groupChatMediator, String name) {
        super(groupChatMediator, name);
    }

    @Override
    void sendMsg(String msg) {
        this.setMsg(msg);
        groupChatMediator.distributeMsg(this);
    }

    @Override
    void receiveMsg(String msg) {
        System.out.println(this.getName() + "接收：" + msg);
    }
}

/**
 * 聊天室中介接口
 *
 * @author lipangpang
 * @date 2021/12/27
 * @description
 */
public interface IGroupChatMediator {
    /**
     * 加入聊天室
     *
     * @param colleague
     */
    void join(IColleague colleague);

    /**
     * 分发群消息
     *
     * @param colleague
     */
    void distributeMsg(IColleague colleague);
}

/**
 * 聊天室中介
 *
 * @author lipangpang
 * @date 2021/12/27
 * @description
 */
public class GroupChatMediator implements IGroupChatMediator {
    private List colleagues = new ArrayList<>();

    @Override
    public void join(IColleague colleague) {
        colleagues.add(colleague);
    }

    @Override
    public void distributeMsg(IColleague colleague) {
        for (IColleague iColleague : colleagues) {
            if (iColleague == colleague) {
                continue;
            }
            iColleague.receiveMsg("[" + colleague.getName() + "]" + colleague.getMsg());
        }
    }
}

public class TestMain {
    public static void main(String[] args) {
        IGroupChatMediator groupChatMediator = new GroupChatMediator();
        IColleague zhangsan = new Colleague(groupChatMediator, "张三");
        IColleague lisi = new Colleague(groupChatMediator, "李四");
        IColleague wangwu = new Colleague(groupChatMediator, "王五");
        groupChatMediator.join(zhangsan);
        groupChatMediator.join(lisi);
        groupChatMediator.join(wangwu);
        zhangsan.sendMsg("你好啊");
        System.out.println("------------------");
        lisi.sendMsg("新年快乐");
        System.out.println("------------------");
        wangwu.sendMsg("happy new year");
    }
}
 
 
结果：
 
 
李四接收：[张三]你好啊
王五接收：[张三]你好啊
------------------
张三接收：[李四]新年快乐
王五接收：[李四]新年快乐
------------------
张三接收：[王五]happy new year
李四接收：[王五]happy new year
 
 
类图：
 
 
手把手教你23种设计模式_第33张图片
 
 
解释器模式
 
 
含义：给分析对象定义一个语言，并定义该语言的文法表示，再设计一个解析器来解释语言中的句子。
 
 
解释器模式结构如下。
 
 
     
  
  1. 抽象表达式（Abstract Expression）角色：定义解释器的接口，约定解释器的解释操作，主要包含解释方法 interpret()。
    2.  
  
  2. 终结符表达式（Terminal Expression）角色：是抽象表达式的子类，用来实现文法中与终结符相关的操作，文法中的每一个终结符
    都有一个具体终结表达式与之相对应。
    3.  
  
  3. 非终结符表达式（Nonterminal Expression）角色：也是抽象表达式的子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式。
    4.  
  
  4. 环境（Context）角色：通常包含各个解释器需要的数据或是公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可
    以从这里获取这些值。
    5.  
  
  5. 客户端（Client）：主要任务是将需要分析的句子或表达式转换成使用解释器对象描述的抽象语法树，然后调用解释器的解释方法，
    当然也可以通过环境角色间接访问解释器的解释方法。
    6.  
 
 
 
示例：实现1+1=2，2-1=1的数学表达式运算。1,2数字是终结符角色，+，-运算符是非终结符角色。
 
 
/**
 * 表达式接口
 *
 * @author lipangpang
 * @date 2021/12/28
 * @description
 */
public interface IExpression {
    /**
     * 解释表达式
     *
     * @return
     */
    Integer interpreter();
}

/**
 * 终结符表达式
 *
 * @author lipangpang
 * @date 2021/12/28
 * @description
 */
public class TerminalExpression implements IExpression {
    /**
     * 当前终结符存储的值
     */
    private Integer value;

    public TerminalExpression(Integer value) {
        this.value = value;
    }

    @Override
    public Integer interpreter() {
        return this.value;
    }
}

/**
 * 非终结符表达式
 *
 * @author lipangpang
 * @date 2021/12/28
 * @description
 */
public abstract class NonTerminalExpression implements IExpression {
    /**
     * 终结符表达式左值
     */
    protected IExpression leftValue;
    /**
     * 终结符表达式右值
     */
    protected IExpression rightValue;

    public NonTerminalExpression(IExpression leftValue, IExpression rightValue) {
        this.leftValue = leftValue;
        this.rightValue = rightValue;
    }

}

/**
 * 加运算非终结符
 *
 * @author lipangpang
 * @date 2021/12/28
 * @description
 */
public class AddExpression extends NonTerminalExpression {
    public AddExpression(IExpression leftValue, IExpression rightValue) {
        super(leftValue, rightValue);
    }

    @Override
    public Integer interpreter() {
        return this.leftValue.interpreter() + this.rightValue.interpreter();
    }
}

/**
 * 减运算非终结符
 *
 * @author lipangpang
 * @date 2021/12/28
 * @description
 */
public class SubExpression extends NonTerminalExpression {
    public SubExpression(IExpression leftValue, IExpression rightValue) {
        super(leftValue, rightValue);
    }

    @Override
    public Integer interpreter() {
        return this.leftValue.interpreter() - this.rightValue.interpreter();
    }
}

/**
 * 计算器环境类
 *
 * @author lipangpang
 * @date 2021/12/29
 * @description
 */
public class CalculatorContext {

    public Integer parse(String info) {
        String[] split = info.split(" ");
        IExpression leftValue = null;//运算左值
        IExpression rightValue = null;//运算右值
        IExpression operator = null;//运算符
        for (String element : split) {
            if (!("+".equals(element) || "-".equals(element))) {
                if (leftValue == null) {
                    leftValue = new TerminalExpression(Integer.parseInt(element));
                    continue;
                }
                if (rightValue == null) {
                    rightValue = new TerminalExpression(Integer.parseInt(element));
                }
            }
        }
        for (String element : split) {
            if ("+".equals(element)) {
                operator = new AddExpression(leftValue, rightValue);
            } else if ("-".equals(element)) {
                operator = new SubExpression(leftValue, rightValue);
            }
        }
        return operator.interpreter();
    }
}

public class TestMain {
    public static void main(String[] args) {
        System.out.println(new CalculatorContext().parse("1 + 1"));
        System.out.println(new CalculatorContext().parse("2 - 1"));
    }
}
 
 
结果：
 
 
2
1
 
 
类图：
 
 
手把手教你23种设计模式_第34张图片
 
 
访问者模式
 
 
含义：将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新
 
 
的操作，为数据结构中的每个元素提供多种访问方式。
 
 
访问者模式结构如下。
 
 
     
  
  1. 抽象访问者（Visitor）角色：定义一个访问具体元素的接口，为每个具体元素类对应一个访问操作 visit() ，该操作中的参数类型标识
    了被访问的具体元素。
    2.  
  
  2. 具体访问者（ConcreteVisitor）角色：实现抽象访问者角色中声明的各个访问操作，确定访问者访问一个元素时该做什么。
    3.  
  
  3. 抽象元素（Element）角色：声明一个包含接受操作 accept() 的接口，被接受的访问者对象作为 accept() 方法的参数。
    4.  
  
  4. 具体元素（ConcreteElement）角色：实现抽象元素角色提供的 accept() 操作，其方法体通常都是 visitor.visit(this) ，另外具体元素
    中可能还包含本身业务逻辑的相关操作。
    5.  
  
  5. 对象结构（Object Structure）角色：是一个包含元素角色的容器，提供让访问者对象遍历容器中的所有元素的方法，通常由 List、
    Set、Map 等聚合类实现。
    6.  
 
 
 
示例：厨师会把面粉做成面条，烘培师会把面粉做成面包；厨师会把鸡蛋做成煎蛋，烘培师会把鸡蛋做成蛋糕。
 
 
/**
 * 原料接口
 *
 * @author lipangpang
 * @date 2021/12/29
 * @description
 */
public interface IMaterial {
    String accept(IPersonVisitor personVisitor);
}

/**
 * 面粉
 *
 * @author lipangpang
 * @date 2021/12/29
 * @description
 */
public class Flour implements IMaterial {
    @Override
    public String accept(IPersonVisitor personVisitor) {
        return personVisitor.create(this);
    }
}

/**
 * 鸡蛋
 *
 * @author lipangpang
 * @date 2021/12/29
 * @description
 */
public class Egg implements IMaterial {
    @Override
    public String accept(IPersonVisitor personVisitor) {
        return personVisitor.create(this);
    }
}

/**
 * 人访问者接口
 *
 * @author lipangpang
 * @date 2021/12/29
 * @description
 */
public interface IPersonVisitor {
    String create(Flour flour);

    String create(Egg egg);
}

/**
 * 烘培师
 *
 * @author lipangpang
 * @date 2021/12/29
 * @description
 */
public class Baker implements IPersonVisitor {
    @Override
    public String create(Flour flour) {
        return "烘培师把面粉做成面包";
    }

    @Override
    public String create(Egg egg) {
        return "烘培师把鸡蛋做成蛋糕";
    }
}

/**
 * 厨师
 *
 * @author lipangpang
 * @date 2021/12/29
 * @description
 */
public class Cook implements IPersonVisitor {
    @Override
    public String create(Flour flour) {
        return "厨师把面粉做成面条";
    }

    @Override
    public String create(Egg egg) {
        return "厨师把鸡蛋做成煎蛋";
    }
}

/**
 * 材料容器
 *
 * @author lipangpang
 * @date 2021/12/29
 * @description
 */
public class MaterialContainer {
    List materials = new ArrayList<>();

    public void addMaterial(IMaterial material) {
        materials.add(material);
    }

    public void accept(IPersonVisitor personVisitor) {
        for (IMaterial material : materials) {
            String result = material.accept(personVisitor);
            System.out.println(result);
        }
    }
}

public class TestMain {
    public static void main(String[] args) {
        MaterialContainer materialContainer = new MaterialContainer();
        materialContainer.addMaterial(new Flour());
        materialContainer.addMaterial(new Egg());
        materialContainer.accept(new Cook());
        System.out.println("------------");
        materialContainer.accept(new Baker());
    }
}
 
 
结果：
 
 
厨师把面粉做成面条
厨师把鸡蛋做成煎蛋
------------
烘培师把面粉做成面包
烘培师把鸡蛋做成蛋糕
 
 
类图：
 
 
手把手教你23种设计模式_第35张图片
 
 
观察者模式
 
 
含义：多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
 
 
观察者模式结构如下。
 
 
     
  
  1. 抽象主题（Subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通
    知所有观察者的抽象方法。
    2.  
  
  2. 具体主题（Concrete Subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所
    有注册过的观察者对象。
    3.  
  
  3. 抽象观察者（Observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
    4.  
  
  4. 具体观察者（Concrete Observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。
    5.  
 
 
 
示例：微信公众号发布新消息时，所有关注者都会接受到信息提醒。
 
 
/**
 * 用户观察者接口
 *
 * @author lipangpang
 * @date 2021/12/30
 * @description
 */
public interface IUserObserver {
    /**
     * 接受消息
     *
     * @param msg
     */
    void receive(String msg);
}

/**
 * @author lipangpang
 * @date 2021/12/30
 * @description
 */
public class UserObserver implements IUserObserver {
    /**
     * 观察者姓名
     */
    private String name;

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

    @Override
    public void receive(String msg) {
        System.out.println(this.name + "接收消息：" + msg);
    }
}

/**
 * 公众号主题抽象类
 *
 * @author lipangpang
 * @date 2021/12/30
 * @description
 */
public abstract class IOfficialAccountSubject {
    /**
     * 所有订阅公众号的用户观察者
     */
    List userObservers = new ArrayList<>();

    /**
     * 订阅公众号
     *
     * @param userObserver
     */
    public void addObserver(IUserObserver userObserver) {
        userObservers.add(userObserver);
    }

    /**
     * 推送消息
     *
     * @param msg
     */
    public abstract void notifyObserver(String msg);
}

/**
 * 公众号
 *
 * @author lipangpang
 * @date 2021/12/30
 * @description
 */
public class OfficialAccountSubject extends IOfficialAccountSubject {
    @Override
    public void notifyObserver(String msg) {
        System.out.println("公众号推送消息:" + msg);
        System.out.println("----------------");
        for (IUserObserver userObserver : userObservers) {
            userObserver.receive(msg);
        }
    }
}

public class TestMain {
    public static void main(String[] args) {
        IOfficialAccountSubject officialAccountSubject = new OfficialAccountSubject();
        UserObserver zhangsan = new UserObserver("zhangsan");
        UserObserver lisi = new UserObserver("lisi");
        officialAccountSubject.addObserver(zhangsan);
        officialAccountSubject.addObserver(lisi);
        officialAccountSubject.notifyObserver("新年快乐");
        System.out.println();
        officialAccountSubject.notifyObserver("给大伙派送红包");
    }
}
 
 
结果：
 
 
公众号推送消息:新年快乐
----------------
zhangsan接收消息：新年快乐
lisi接收消息：新年快乐

公众号推送消息:给大伙派送红包
----------------
zhangsan接收消息：给大伙派送红包
lisi接收消息：给大伙派送红包
 
 
类图：
 
 
手把手教你23种设计模式_第36张图片
 
 
委派模式（不属于GoF 23 种设计模式）
 
 
含义：负责任务的调度和分配任务。
 
 
示例：实现servlet的请求，根据不同的用户请求url调用不同的方法。
 
 
/**
 * 商品控制器
 *
 * @author lipangpang
 * @date 2021/12/30
 * @description
 */
public class ProductController {
    public void getProductInfo() {
        System.out.println("这是商品信息");
    }
}

/**
 * 用户控制器
 *
 * @author lipangpang
 * @date 2021/12/30
 * @description
 */
public class UserController {
    public void getUserInfo() {
        System.out.println("这是用户信息");
    }
}

/**
 * servlet接口
 *
 * @author lipangpang
 * @date 2021/12/30
 * @description
 */
public interface IServlet {
    Object dispatcher(String url);
}

/**
 * servlet
 *
 * @author lipangpang
 * @date 2021/12/30
 * @description
 */
public class Servlet implements IServlet {

    @Override
    public Object dispatcher(String url) {
        if ("/user".equals(url)) {
            new UserController().getUserInfo();
        } else if ("/product".equals(url)) {
            new ProductController().getProductInfo();
        }
        return null;
    }
}


/**
 * 客户端
 *
 * @author lipangpang
 * @date 2021/12/30
 * @description
 */
public class Client {
    private IServlet servlet;

    public Client(IServlet servlet) {
        this.servlet = servlet;
    }

    public void sendCommand(String url) {
        this.servlet.dispatcher(url);
    }
}

public class TestMain {
    public static void main(String[] args) {
        Servlet servlet = new Servlet();
        Client client = new Client(servlet);
        client.sendCommand("/user");
        client.sendCommand("/product");
    }
}
 
 
结果：
 
 
这是用户信息
这是商品信息
 
 
类图：
 
 
手把手教你23种设计模式_第37张图片
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(设计模式java)

        

            

                
    
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                    
  • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    
                    
    • 
                                
  • JAVA中的Enum
                                    周凡杨
javaenum枚举
                                    
    Enum是计算机编程语言中的一种数据类型---枚举类型。 在实际问题中，有些变量的取值被限定在一个有限的范围内。       例如，一个星期内只有七天 我们通常这样实现上面的定义： 
public String monday;
public String tuesday;
public String wensday;
public String thursday
    
                                
    • 
                                
  • 赶集网mysql开发36条军规
                                    Bill_chen
mysql业务架构设计mysql调优mysql性能优化
                                    
    (一)核心军规   (1)不在数据库做运算      cpu计算务必移至业务层；   (2)控制单表数据量      int型不超过1000w，含char则不超过500w；      合理分表；      限制单库表数量在300以内；   (3)控制列数量      字段少而精，字段数建议在20以内
    
                                
    • 
                                
  • Shell test命令
                                    daizj
shell字符串test数字文件比较
                                    
    Shell test命令 
Shell中的 test 命令用于检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试。  数值测试    参数 说明   -eq 等于则为真   -ne 不等于则为真   -gt 大于则为真   -ge 大于等于则为真   -lt 小于则为真   -le 小于等于则为真    
实例演示： 
num1=100
num2=100if test $[num1]
    
                                
    • 
                                
  • XFire框架实现WebService(二)
                                    周凡杨
javawebservice
                                    
       有了XFire框架实现WebService(一)，就可以继续开发WebService的简单应用。 
Webservice的服务端(WEB工程)： 
两个java bean类： 
Course.java 
   package cn.com.bean; 
public class Course { 
    private 
    
                                
    • 
                                
  • 重绘之画图板
                                    朱辉辉33
画图板
                                    
           上次博客讲的五子棋重绘比较简单，因为只要在重写系统重绘方法paint（）时加入棋盘和棋子的绘制。这次我想说说画图板的重绘。 
       画图板重绘难在需要重绘的类型很多，比如说里面有矩形，园，直线之类的，所以我们要想办法将里面的图形加入一个队列中，这样在重绘时就
    
                                
    • 
                                
  • Java的IO流
                                    西蜀石兰
java
                                    
    刚学Java的IO流时，被各种inputStream流弄的很迷糊，看老罗视频时说想象成插在文件上的一根管道，当初听时觉得自己很明白，可到自己用时，有不知道怎么代码了。。。 
每当遇到这种问题时，我习惯性的从头开始理逻辑，会问自己一些很简单的问题，把这些简单的问题想明白了，再看代码时才不会迷糊。 
 
IO流作用是什么？ 
答：实现对文件的读写，这里的文件是广义的； 
 
Java如何实现程序到文件
    
                                
    • 
                                
  • No matching PlatformTransactionManager bean found for qualifier 'add' - neither
                                    林鹤霄

                                    
    java.lang.IllegalStateException: No matching PlatformTransactionManager bean found for qualifier 'add' - neither qualifier match nor bean name match! 
  
网上找了好多的资料没能解决，后来发现：项目中使用的是xml配置的方式配置事务，但是
    
                                
    • 
                                
  • Row size too large (> 8126). Changing some columns to TEXT or BLOB
                                    aigo
column
                                    
    原文：http://stackoverflow.com/questions/15585602/change-limit-for-mysql-row-size-too-large 
  
异常信息： 
Row size too large (> 8126). Changing some columns to TEXT or BLOB or using ROW_FORMAT=DYNAM
    
                                
    • 
                                
  • JS 格式化时间
                                    alxw4616
JavaScript
                                    
    /**
 * 格式化时间 2013/6/13 by 半仙 [email protected]
 * 需要 pad 函数
 * 接收可用的时间值.
 * 返回替换时间占位符后的字符串
 *
 * 时间占位符:年 Y 月 M 日 D 小时 h 分 m 秒 s 重复次数表示占位数
 * 如 YYYY 4占4位 YY 占2位<p></p>
 * MM DD hh mm
    
                                
    • 
                                
  • 队列中数据的移除问题
                                    百合不是茶
队列移除
                                    
      
   队列的移除一般都是使用的remov();都可以移除的,但是在昨天做线程移除的时候出现了点问题,没有将遍历出来的全部移除,  代码如下; 
  
   // 
package com.Thread0715.com;

import java.util.ArrayList;

public class Threa
    
                                
    • 
                                
  • Runnable接口使用实例
                                    bijian1013
javathreadRunnablejava多线程
                                    
    Runnable接口 
a.       该接口只有一个方法：public void run(); 
b.       实现该接口的类必须覆盖该run方法 
c.       实现了Runnable接口的类并不具有任何天
    
                                
    • 
                                
  • oracle里的extend详解
                                    bijian1013
oracle数据库extend
                                    
    扩展已知的数组空间，例： 
DECLARE
  TYPE CourseList IS TABLE OF VARCHAR2(10);
  courses CourseList;
BEGIN
  --   初始化数组元素，大小为3
  courses := CourseList('Biol   4412 ', 'Psyc   3112 ', 'Anth   3001 ');
  --   
    
                                
    • 
                                
  • 【httpclient】httpclient发送表单POST请求
                                    bit1129
httpclient
                                    
    浏览器Form Post请求 
浏览器可以通过提交表单的方式向服务器发起POST请求，这种形式的POST请求不同于一般的POST请求 
1. 一般的POST请求，将请求数据放置于请求体中，服务器端以二进制流的方式读取数据，HttpServletRequest.getInputStream()。这种方式的请求可以处理任意数据形式的POST请求，比如请求数据是字符串或者是二进制数据 
2. Form 
    
                                
    • 
                                
  • 【Hive十三】Hive读写Avro格式的数据
                                    bit1129
hive
                                    
     1. 原始数据 
hive> select * from word; 
OK
1	MSN  
10	QQ  
100	Gtalk  
1000	Skype  
  
  
 2. 创建avro格式的数据表 
  
hive> CREATE TABLE avro_table(age INT, name STRING)STORE
    
                                
    • 
                                
  • nginx+lua+redis自动识别封解禁频繁访问IP
                                    ronin47

                                    
    在站点遇到攻击且无明显攻击特征，造成站点访问慢，nginx不断返回502等错误时，可利用nginx+lua+redis实现在指定的时间段 内，若单IP的请求量达到指定的数量后对该IP进行封禁，nginx返回403禁止访问。利用redis的expire命令设置封禁IP的过期时间达到在 指定的封禁时间后实行自动解封的目的。 
一、安装环境： 
 
 CentOS x64 release 6.4(Fin
    
                                
    • 
                                
  • java-二叉树的遍历-先序、中序、后序（递归和非递归）、层次遍历
                                    bylijinnan
java
                                    
    
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;


public class BinTreeTraverse {
	//private int[] array={ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	private int[] array={ 10,6,
    
                                
    • 
                                
  • Spring源码学习-XML 配置方式的IoC容器启动过程分析
                                    bylijinnan
javaspringIOC
                                    
    以FileSystemXmlApplicationContext为例，把Spring IoC容器的初始化流程走一遍： 
 

ApplicationContext context = new FileSystemXmlApplicationContext
            ("C:/Users/ZARA/workspace/HelloSpring/src/Beans.xml&q
    
                                
    • 
                                
  • [科研与项目]民营企业请慎重参与军事科技工程
                                    comsci
企业
                                    
     
 
     军事科研工程和项目 并非要用最先进，最时髦的技术，而是要做到“万无一失” 
 
   而民营科技企业在搞科技创新工程的时候，往往考虑的是技术的先进性，而对先进技术带来的风险考虑得不够，在今天提倡军民融合发展的大环境下，这种“万无一失”和“时髦性”的矛盾会日益凸显。。。。。。所以请大家在参与任何重大的军事和政府项目之前，对
    
                                
    • 
                                
  • spring 定时器-两种方式
                                    cuityang
springquartz定时器
                                    
    方式一： 
间隔一定时间 运行 
 
<bean id="updateSessionIdTask" class="com.yang.iprms.common.UpdateSessionTask" autowire="byName" /> 
 
 <bean id="updateSessionIdSchedule
    
                                
    • 
                                
  • 简述一下关于BroadView站点的相关设计
                                    damoqiongqiu
view
                                    
    终于弄上线了，累趴，戳这里http://www.broadview.com.cn 
  
简述一下相关的技术点 
  
前端：jQuery+BootStrap3.2+HandleBars，全站Ajax（貌似对SEO的影响很大啊！怎么破？），用Grunt对全部JS做了压缩处理，对部分JS和CSS做了合并（模块间存在很多依赖，全部合并比较繁琐，待完善）。 
  
后端：U
    
                                
    • 
                                
  • 运维 PHP问题汇总
                                    dcj3sjt126com
windows2003
                                    
    1、Dede(织梦)发表文章时,内容自动添加关键字显示空白页 
解决方法： 
后台>系统>系统基本参数>核心设置>关键字替换（是/否），这里选择“是”。 
后台>系统>系统基本参数>其他选项>自动提取关键字，这里选择“是”。 
  
2、解决PHP168超级管理员上传图片提示你的空间不足 
网站是用PHP168做的，反映使用管理员在后台无法
    
                                
    • 
                                
  • mac 下 安装php扩展 - mcrypt
                                    dcj3sjt126com
PHP
                                    
    MCrypt是一个功能强大的加密算法扩展库，它包括有22种算法，phpMyAdmin依赖这个PHP扩展，具体如下： 
 
  
  下载并解压libmcrypt-2.5.8.tar.gz。 
  在终端执行如下命令：  tar zxvf libmcrypt-2.5.8.tar.gz cd libmcrypt-2.5.8/ ./configure --disable-posix-threads --
    
                                
    • 
                                
  • MongoDB更新文档 [四]
                                    eksliang
mongodbMongodb更新文档
                                    
    MongoDB更新文档 
转载请出自出处：http://eksliang.iteye.com/blog/2174104 
MongoDB对文档的CURD，前面的博客简单介绍了，但是对文档更新篇幅比较大，所以这里单独拿出来。 
语法结构如下： 
db.collection.update( criteria, objNew, upsert, multi) 
参数含义    参数   
    
                                
    • 
                                
  • Linux下的解压，移除，复制，查看tomcat命令
                                    y806839048
tomcat
                                    
    重复myeclipse生成webservice有问题删除以前的，干净 
 
 1、先切换到：cd usr/local/tomcat5/logs 
 
2、tail -f catalina.out 
 
3、这样运行时就可以实时查看运行日志了 
 
 
 
 
Ctrl+c 是退出tail命令。 
 有问题不明的先注掉 
   cp /opt/tomcat-6.0.44/webapps/g
    
                                
    • 
                                
  • Spring之使用事务缘由(3-XML实现)
                                    ihuning
spring
                                    
      
用事务通知声明式地管理事务 
  
事务管理是一种横切关注点。为了在 Spring 2.x 中启用声明式事务管理，可以通过 tx Schema 中定义的 <tx:advice> 元素声明事务通知，为此必须事先将这个 Schema 定义添加到 <beans> 根元素中去。声明了事务通知后，就需要将它与切入点关联起来。由于事务通知是在 <aop:
    
                                
    • 
                                
  • GCD使用经验与技巧浅谈
                                    啸笑天
GC
                                    
    前言 
GCD(Grand Central Dispatch)可以说是Mac、iOS开发中的一大“利器”，本文就总结一些有关使用GCD的经验与技巧。 
dispatch_once_t必须是全局或static变量 
这一条算是“老生常谈”了，但我认为还是有必要强调一次，毕竟非全局或非static的dispatch_once_t变量在使用时会导致非常不好排查的bug，正确的如下：        1  
    
                                
    • 
                                
  • linux（Ubuntu）下常用命令备忘录1
                                    macroli
linux工作ubuntu
                                    
    在使用下面的命令是可以通过--help来获取更多的信息1,查询当前目录文件列表：ls 
 
 ls命令默认状态下将按首字母升序列出你当前文件夹下面的所有内容，但这样直接运行所得到的信息也是比较少的，通常它可以结合以下这些参数运行以查询更多的信息：  
 ls / 显示/.下的所有文件和目录  
 ls -l 给出文件或者文件夹的详细信息 
 ls -a 显示所有文件，包括隐藏文
    
                                
    • 
                                
  • nodejs同步操作mysql
                                    qiaolevip
学习永无止境每天进步一点点mysqlnodejs
                                    
    // db-util.js
var mysql = require('mysql');
var pool = mysql.createPool({
  connectionLimit : 10,
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'test',
  port: 3306
});


    
                                
    • 
                                
  • 一起学Hive系列文章
                                    superlxw1234
hiveHive入门
                                    
      
[一起学Hive]系列文章 目录贴，入门Hive，持续更新中。 
  
[一起学Hive]之一—Hive概述，Hive是什么 
[一起学Hive]之二—Hive函数大全-完整版 
[一起学Hive]之三—Hive中的数据库(Database)和表(Table) 
[一起学Hive]之四-Hive的安装配置 
[一起学Hive]之五-Hive的视图和分区 
[一起学Hive
    
                                
    • 
                                
  • Spring开发利器：Spring Tool Suite 3.7.0 发布
                                    wiselyman
spring
                                    
    Spring Tool Suite(简称STS)是基于Eclipse，专门针对Spring开发者提供大量的便捷功能的优秀开发工具。 
  
在3.7.0版本主要做了如下的更新： 
  
 
 将eclipse版本更新至Eclipse Mars 4.5 GA 
 Spring Boot(JavaEE开发的颠覆者集大成者，推荐大家学习)的配置语言YAML编辑器的支持(包含自动提示，
    
                                
    •