静态跟动态代理

1、实现静态代理类 

                

 实现静态代理类

package cn.yix.spring.service;

import lombok.NoArgsConstructor;

@NoArgsConstructor
public class EmpServiceConfig {
    /**
     *  代理类的接口
     */
    private EmpService empService;

    /**
     * 使用构造方法 注入 代理类
     * @param empService
     */
    public EmpServiceConfig(EmpService empService){
        this.empService=empService;
    }

    /**
     * 代理模块
     */
    public void getconnect(){
        System.out.println("取得连接");
    }
    public void  colosconnect(){
        System.out.println("关闭连接");
    }

    /**
     * 实现代理
     */
    public void addEmp(){
        this.getconnect();
        this.empService.insertEmp();
        this.colosconnect();
    }
}

运行代理类

1（） 分析静态代理类的不足  其一 耦合性过高 我可以观察 静态代理实现类中 我们是通过构造方法注入 被代理类的接口 来注入完成代理的这一个过程 所以 加入我们需要代理大量的类的情况下静态代理显然不能满足我们开发者的需求 对于后期的维护更新也会造成影响。 解决方法：动态代理

2、实现动态代理类（InvocationHandler-proxy） 

        

package cn.yix.spring.service;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 *
 */
public class ObjcetProxy implements InvocationHandler {
    //代理类真实体类做主体增强
    private Object object;
    public ObjcetProxy(Object object){
        this.object=object;
    }

    /**
     * 前置增强
     */
    public void getconnect(){
        System.out.println("取得连接");
    }

    /**
     * 后置增强
     */
    public void  colosconnect(){
        System.out.println("关闭连接");
    }

    /**
     *
     * @param proxy  被代理对象
     *
     * @param method 要执行的目标方法（切点）
     *
     * @param args 传递给目标方法的参数
     *
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        this.getconnect();
        //指定目标方法
        Object invoke = method.invoke(object, args);
        this.colosconnect();
        return invoke;
    }
}

package cn.yix.spring;

import cn.yix.spring.service.EmpService;
import cn.yix.spring.service.EmpServiceproxy;
import cn.yix.spring.service.Impl.EmpserviceImpl;
import cn.yix.spring.service.ObjcetProxy;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;


public class Test {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringTest.class);
        EmpserviceImpl bean = applicationContext.getBean(EmpserviceImpl.class);
        //创建被代理类实体对象
        EmpService empservice = new EmpserviceImpl();
        /**通过 invocationHandler 取得真实主体类对象的代理对象
         *  第一个参数：类的加载器
         *  第二个参数： 真实主题类的所有接口类型
         *  第三个参数 ： 代理类对象
         */
        InvocationHandler handler = new ObjcetProxy(empservice);
        EmpService proxyInstance = (EmpService) Proxy
                .newProxyInstance(handler.getClass().getClassLoader(),
                        empservice.getClass().getInterfaces(),
                        handler);
        System.out.println("========================");
        proxyInstance.insertEmp();


    }
}