java之装饰模式和代理模式

裝飾模式

一：装饰者可以在所委托被装饰者的行为之前与/或之后，加上自己的行为，以达到特定的目的。

10     public String operation(){
11         return com.operation()+cl;//位置互换
12     }

二：装饰者和被装饰者有共同的基类，我们利用继承达到“类型匹配”，而不是利用继承获得“行为”，新行为由组合对象得来的。

10     public String operation(){
11         return com.operation()+cl;//接口回调具体被装饰者和具体装饰者的operation()方法
12     }

注：抽象装饰者可有可无

//抽象被裝飾者
public abstract class Component{
    private String lsh="output:";//output:生成流水號
    public abstract String operation();//抽象方法（包裝）
    public String getlsh(){
        return lsh;
    }
}

//具體被裝飾者
public class detailComponent extends Component {
    @Override
    public String operation(){
        return getlsh();
    }
}

//具體裝飾者：常量
public class constant extends Component {
    private Component com;
    private String cl;
    public constant(Component com, String cl){
        this.com=com;
        this.cl=cl;
    }
    @Override
    public String operation(){
        return com.operation()+cl;
    }
}

//具體裝飾者：自增數
public class num extends Component {
    private Component com;
    private String num;
    public num (Component com, String num){
        this.com=com;
        this.num=num;
    }
    @Override
    public String operation(){
        return com.operation()+num;
    }
}

//具體裝飾者：日期
public class time extends Component {
    private Component com;
    private String rq;
    public time (Component com, String rq){
        this.rq=rq;
        this.com=com;
    }
    @Override
    public String operation(){
        return com.operation()+rq;
    }
}

//測試
public class test {
    public static void main(String[] args) {
        //客戶端傳來 三個 規則
        String a = "DB";
        String b = "YYYY";
        String c = "001";
        //當前時間 字符串
        b = cDate(b);
         Component com = new  detailComponent();//創建 被裝飾者
        com  = new  num(new  time(new constant(com,a),b),c);//裝飾
        System.out.println(com.operation());//輸出為：output:DB2020001
        Component com2 = new detailComponent();//創建 被裝飾者
        c = autoNum(c);//c+1
        com2  = new num(new time(new constant(com2,a),b),c);
        System.out.println(com2.operation());//輸出為：output:DB2020002
    }
    public static String autoNum(String c){
        StringBuilder strbd = new StringBuilder();
        int i,j;
        i = Integer.parseInt(c);
        i++;
        int d = c.length()-Integer.toString(i).length();
        j=0;
        while(j<d){
            j++;
            strbd.append("0");
        }
        strbd.append(i);
        return strbd.toString();
    }
    public static String cDate(String b){
        SimpleDateFormat dateFormat ;
        String str = null;
        if(b.length()==8) {
            str = "YYYYMMDD";
        }
        else if(b.length()==6){
            str = "YYYYMM";
        }
        else if(b.length()==4){
            str = "YYYY";
        }else {
            return "error";
        }
        dateFormat = new SimpleDateFormat(str);
        String currentDate = dateFormat.format(new Date());
        return currentDate;
    }
}

 

 

代理模式

靜態代理

 

//目標接口
public interface Star {
    public void show();
    public void sing();
}
//工具
public class Tool {
    private String microphone;
    private String cap;
    public tool(){}
    public setMicrophone(String microphone){
        this.microphone=microphone;
    }
    public getMicrophone(){
        return microphone;
    }
    public setCap(String cap){
        this.cap=cap;
    }
    public getCap(){
        return cap;
    }
}
//目標對象
public class Chris implements Star {
    public Chris(){}
    public void show(){
        System.out.println("表演了魔術。");
    }
    public void sing(){
        System.out.println("唱了一首海闊天空。");
    }
}
//代理類
public class Proxy implements Star {
    private Tool tool;
    private Star star;
    public Proxy(Tool tool,Star star){
        this.tool=tool;
        this.Star=star;
    }
    @Override
    public void show(){
        tool.setCap("魔術帽");
        System.out.println("start:"+getCap());
        star.show();
        System.out.println("over");
    }
    public void sing(){
        tool.setMicrophone("藍牙麥克風");
        System.out.println("start:"+getMicrophone());        
        star.sing();
        System.out.println("over");
    }
}
//客戶端
public class client {
    public static void main(String[] args){
        Proxy proxy = new (new Tool(),new Chris());
        proxy.sing();
        proxy.show();
    }
} 

動態代理（JDK動態代理）

　　动态代理的对象必须实现一个或多个接口

//調用處理程序
public class ProxyFactory{
    private Object target;
    public ProxyFactory(Object target){
        this.target=target;
    }
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(//生成代理實例
                target.getClass().getClassLoader(),//类加载器
                target.getClass().getInterfaces(),//增强方法所在的类实现的一个或多个接口
                new InvocationHandler() {//調用代理實例
                    /*
                    *proxy 生成的代理實例
                    *method 代理實例被調用的方法
                    *args 代理實例被調用的方法參數
                    */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("事務1");
                        Object returnValue = method.invoke(target, args);
                        System.out.println("事務2");
                        return returnValue;
                    }
                }
        );
    }
}
//客戶端2
public class client {
    public static void main(String[] args){
        Star target = new Chris();
        System.out.println(target.getClass());//...Chris.class
        Star proxy = (Star)new ProxyFactory(target).getProxyInstance();//...$Proxy0.class
        proxy.show();
        proxy.sing();
    }
} 

動態代理（CGLIB動態代理）

　　动态代理的对象沒有实现接口

//目標對象
public class Chris {
    public Chris(){}
    public void show(){
        System.out.println("表演了魔術。");
    }
    public void sing(){
        System.out.println("唱了一首海闊天空。");
    }
}
public class ProxyFactory implements MethodInterceptor{
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }
    public Object getProxyInstance(){//生成代理實例
        Enhancer en = new Enhancer();//工具類
        en.setSuperclass(target.getClass());//設置父類
        en.setCallback(this);//設置回調函數
        return en.create();//創建子類
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {//調用代理實例
        System.out.println("事務1");
        Object returnValue = method.invoke(target, args);
        System.out.println("事務2");
        return returnValue;
    }
}
//客戶端3
public class client {
    public static void main(String[] args){
        Chris target = new Chris();
        System.out.println(target.getClass());//...Chris.class
        Chris proxy = (Chris)new ProxyFactory(target).getProxyInstance();//...$Proxy0.class
        proxy.show();
        proxy.sing();
    }
} 

 Spring AOP 

面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术，AOP是OOP（面向对象编程）的延续。

利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，動態添加功能：日誌，安全，事務等。

1.通知（Advice）：安全，事务，日志等功能

2.连接点（JoinPoint）：spring允许你使用通知的地方

3.切入点（Pointcut）：切点来筛选连接点，选中那几个你想要的方法

4.切面（Aspect）：切面是通知和切入点的结合

5.引入（introduction）：把切面用到目標方法

6.目标（target）：目标类，也就是要被通知的对象，也就是真正的业务逻辑

7.代理(proxy)：代理

8.织入(weaving)：把切面应用到目标对象来创建新的代理对象的过程

 

 

 

 

 

 

 

 

参考文章：

代理模式

https://www.cnblogs.com/echola/p/11004069.html

https://segmentfault.com/a/1190000019433930?utm_source=tag-newest

裝飾模式

https://www.cnblogs.com/ZhangHaoShuaiGe/p/7866610.html