1
package com.cskaoyan.pattern.singleton;
2

3
/**
4
 * 饿汉式
5
 **/
6
public class Singleton1 {
7

8
    //创建私有静态实例对象
9
    private static final Singleton1 instance = new Singleton1();
10

11
    //私有化构造函数
12
    private Singleton1(){}
13

14
    public static Singleton1 getInstance(){
15
        return instance;
16
    }
17
}

1
package com.cskaoyan.pattern.singleton;
2

3
/**
4
 * 懒汉式-线程不安全
5
 **/
6
public class Singleton2 {
7

8
    private static Singleton2 instance;
9

10
    //私有化构造函数
11
    private Singleton2(){}
12

13
    //判断当前对象是否已经被创建
14
    public static Singleton2 getInstance(){
15
        if(instance == null){
16
            instance = new Singleton2();
17
        }
18
        return instance;
19
    }
20
}

1
package com.cskaoyan.pattern.singleton;
2

3
/**
4
 * 懒汉式-线程安全
5
 * @Version V1.0
6
 **/
7
public class Singleton3 {
8

9
    private static Singleton3 instance;
10

11
    //私有化构造函数
12
    private Singleton3(){}
13

14
    //引入synchronized，保证多线程模式下实例对象的唯一性
15
    public static synchronized Singleton3 getInstance(){
16
        if(instance == null){
17
            instance = new Singleton3();
18
        }
19
        return instance;
20
    }
21
}

1
package com.cskaoyan.pattern.singleton;
2

3
/**
4
* 懒汉式-双重检查
5
**/
6
public class Singleton4 {
7

8
   private static Singleton4 instance;
9

10
   //私有化构造函数
11
   private Singleton4(){}
12

13
   public static Singleton4 getInstance(){
14
       if(instance == null){
15
           synchronized (Singleton4.class){
16
               if(instance == null){
17
                   instance = new Singleton4();
18
               }
19
           }
20
       }
21
       return instance;
22
   }
23
}

1
public class Singleton5 {
2

3
    private static Singleton5 instance;
4

5

6
    //私有化构造函数
7
    private Singleton5(){}
8

9
    //静态内部类
10
    private static class SingletonHolder{
11
        private static Singleton5 instance = new Singleton5();
12
    }
13

14
    public static Singleton5 getInstance(){
15

16
        return SingletonHolder.instance;
17
    }
18
}

1
public abstract class Tesla {
2
    String name;
3
    public Tesla(String name) {
4
        this.name = name;
5
    }
6
    public void run(){
7
        System.out.println(name + "在路上跑");
8
    }
9
}
10
public class Model3 extends Tesla{
11
    public Model3() {
12
        super("model 3");
13
    }
14
}
15
public class ModelS extends Tesla{
16
    public ModelS() {
17
        super("model S");
18
    }
19
}
20
public class ModelY extends Tesla{
21
    public ModelY() {
22
        super("model Y");
23
    }
24
}

1
Scanner scanner = new Scanner(System.in);
2
String keyword = scanner.nextLine();
3
Tesla tesla = null;
4
switch (keyword) {
5
    case "model3":
6
        tesla = new Model3();
7
        break;
8
    case "modely":
9
        tesla = new ModelY();
10
        break;
11
    case "models":
12
        tesla = new ModelS();
13
        break;
14
    default:
15
        tesla = new Tesla("未知车辆") {
16
            @Override
17
            public void run() {
18
                System.out.println(name + "路上请注意，道路千万条，安全第一条");
19
            }
20
        };
21
        break;
22
}
23
tesla.run();

1
public class SimpleTeslaFactory {
2

3
    public static Tesla create(String keyword) {
4
        Tesla tesla = null;
5
        switch (keyword) {
6
            case "model3":
7
                tesla = new Model3();
8
                break;
9
            case "modely":
10
                tesla = new ModelY();
11
                break;
12
            case "models":
13
                tesla = new ModelS();
14
                break;
15
            default:
16
                tesla = new Tesla("未知车辆") {
17
                    @Override
18
                    public void run() {
19
                        System.out.println(name + "路上请注意，道路千万条，安全第一条");
20
                    }
21
                };
22
                break;
23
        }
24
        return tesla;
25
    }
26
}

1
import java.util.Scanner;
2

3
/**
4
 * @ClassName OrderCar
5
 * @Description: TODO
6
 * @Author stone
7
 * @Date 2023/2/28 20:05
8
 * @Version V1.0
9
 **/
10
public class OrderCar {
11

12
    public static void main(String[] args) {
13
        Scanner scanner = new Scanner(System.in);
14
        String keyword = scanner.nextLine();
15
        Tesla tesla = SimpleTeslaFactory.create(keyword);
16
        tesla.run();
17
    }
18
}

1
public class OrderTesla {
2

3
    private static Map<String, TeslaFactory> factoryMap = new HashMap<>();
4

5
    static {
6
        factoryMap.put("modelx", new ModelXFactory());
7
        factoryMap.put("modely", new ModelYFactory());
8
        factoryMap.put("models", new ModelSFactory());
9
        factoryMap.put("model3", new Model3Factory());
10
    }
11

12
    public static void main(String[] args) {
13
        Scanner scanner = new Scanner(System.in);
14
        String keywords = scanner.nextLine();
15
        TeslaFactory teslaFactory = factoryMap.get(keywords.toLowerCase());
16
        Tesla tesla = teslaFactory.getTesla();
17
        tesla.run();
18
    }
19
}

1
public class UserServiceProxy implements UserService {
2

3
    UserService target;
4

5
    public UserServiceProxy(UserService target) {
6
        //注入委托类对象
7
        this.target = target;
8
    }
9

10
    @Override
11
    public void insert() {
12
        System.out.println("代理之前打印一个日志");
13
        target.insert();
14
        System.out.println("代理之后打印一个日志");
15
    }
16
}

1
public class ProxyFactory {
2

3
    Object target;
4

5
    public ProxyFactory(Object target) {
6
        this.target = target;
7
    }
8

9
    public Object newProxyInstance(){
10
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
11
                target.getClass().getInterfaces(),
12
                new InvocationHandler() {
13

14
                    //代理类如何代理
15
                    @Override
16
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
17
                        System.out.println("代理之前签订合约");
18
                        Object invoke = method.invoke(target, args);
19
                        System.out.println("代理完毕转账确认");
20
                        return invoke;
21
                    }
22
                });
23
    }
24
}

1
@Test
2
    public void test2(){
3
        UserService userService = new UserServiceImpl();
4
        //对哪个目标类进行代理，我们对UserServiceImpl进行代理
5
        //生成代理类对象
6
        UserService userServiceProxy = Proxy.newProxyInstance(target.getClass().getClassLoader(),
7
                target.getClass().getInterfaces(),
8
                new InvocationHandler() {
9

10
                    //代理类如何代理
11
                    @Override
12
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
13
                        System.out.println("代理之前签订合约");
14
                        Object invoke = method.invoke(userService, args);
15
                        System.out.println("代理完毕转账确认");
16
                        return invoke;
17
                    }
18
                });;
19
        //代理类对象执行insert方法，什么逻辑呢？主要是invoke里面的代码逻辑
20
        userServiceProxy.insert();
21
    }

1
public final class $Proxy0
2
extends Proxy
3
implements UserService {
4
    private static Method m1;
5
    private static Method m3;
6
    private static Method m2;
7
    private static Method m0;
8

9
    public $Proxy0(InvocationHandler invocationHandler) {
10
        super(invocationHandler);
11
    }
12

13
    static {
14
        try {
15
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
16
            m3 = Class.forName("com.cskaoyan.pattern.proxy.UserService").getMethod("insert", new Class[0]);
17
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
18
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
19
            return;
20
        }
21
        catch (NoSuchMethodException noSuchMethodException) {
22
            throw new NoSuchMethodError(noSuchMethodException.getMessage());
23
        }
24
        catch (ClassNotFoundException classNotFoundException) {
25
            throw new NoClassDefFoundError(classNotFoundException.getMessage());
26
        }
27
    }
28

29
    public final boolean equals(Object object) {
30
        try {
31
            return (Boolean)this.h.invoke(this, m1, new Object[]{object});
32
        }
33
        catch (Error | RuntimeException throwable) {
34
            throw throwable;
35
        }
36
        catch (Throwable throwable) {
37
            throw new UndeclaredThrowableException(throwable);
38
        }
39
    }
40

41
    public final String toString() {
42
        try {
43
            return (String)this.h.invoke(this, m2, null);
44
        }
45
        catch (Error | RuntimeException throwable) {
46
            throw throwable;
47
        }
48
        catch (Throwable throwable) {
49
            throw new UndeclaredThrowableException(throwable);
50
        }
51
    }
52

53
    public final int hashCode() {
54
        try {
55
            return (Integer)this.h.invoke(this, m0, null);
56
        }
57
        catch (Error | RuntimeException throwable) {
58
            throw throwable;
59
        }
60
        catch (Throwable throwable) {
61
            throw new UndeclaredThrowableException(throwable);
62
        }
63
    }
64
  //主要关注insert方法
65
    public final void insert() {
66
        try {
67
            this.h.invoke(this, m3, null);
68
            return;
69
        }
70
        catch (Error | RuntimeException throwable) {
71
            throw throwable;
72
        }
73
        catch (Throwable throwable) {
74
            throw new UndeclaredThrowableException(throwable);
75
        }
76
    }
77
}

1
public class ProxyTest {
2

3
    public static void main(String[] args) {
4
        UserServiceImpl userService = new UserServiceImpl();
5

6
        UserServiceImpl userServiceProxy = Enhancer.create(UserServiceImpl.class,new InvocationHandler() {
7

8
            //代理类如何代理
9
            @Override
10
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
11
                System.out.println("目标方法执行之前");
12
                Object invoke = method.invoke(userService, args);
13
                System.out.println("目标方法执行之后");
14
                return invoke;
15
            }
16
        });
17
        String name = userServiceProxy.getName();
18
        System.out.println(name);
19
    }
20
}