动态代理规则

代码解析

package com.jt.demo1.porxy;

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

public class JDKProxy2 {
    public static Object getProxy(Object target) {
        //1.传递类加载器
        ClassLoader classLoader = target.getClass().getClassLoader();
        //2.获取接口类型数组
        Class[] interfaces = target.getClass().getInterfaces();
        //代理对象执行方法时候，才会执行业务的扩展功能
        return Proxy.newProxyInstance(classLoader,interfaces,getInvocationHandler(target));
    }


        public static InvocationHandler getInvocationHandler(Object target) {
           return new InvocationHandler() {
               @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;



           }
        };

    }
}

代码解释

动态JDK代理原理是写框架的基本，

1.代理对象怎么来的？有代理的类通过方法调用动态返回来的，所以需要提供一个方法

public static Object getProxy( Object  target){ 

            //1.传递类加载器（获取的话，用到了反射）

          ClassLoader classLoader = target.getClass().getClassLoader();     

            //2.获取接口类型的数组

          Class[  ] interfaces = target.getClass().getInterfaces();

            

         return Proxy.new ProxyIntance(classLoader,interfaces,null )                 

}

 public static InvocationHandler getInvocationHandler(Object target) {

return new InvocationHandler() {
    @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;

｝

为没什么不写对象名，用Object ?工具API，不知道用户需求

Proxy.new ProxyIntance通过这个工具API，可以创造出一个代理对象

第一个参数为什么要传递类加载器？创建出来的对象和本身是一摸一样的，所以需要知道当前类是什么样的，需要通过类加载器获取

Object:目标对象通过用户传进来     target:形参变量

想要和代理对象看起来和真实对象一模一样，方法一样即可

用代理对象的目的：在代理对象的内部进行业务调用，（这里用到一个规则：代理对象在执行方法的时候才会执行代理对象里面的内容）

上到下进行了一个方法的调用getInvocationHandler

 InvocationHandler 是一个接口，所以第二个可以 return new 一个接口，所有方法都得重写

这个invoke方法在代理对象执行方法的时候，才会被执行，也就是业务调用

**需要考虑业务逻辑中会不会有返回值 

最后把返回值交还给用户 

 除此之外，需要创建一个config层（SpringConfig），service(UserServoce   UserServiceImpl)

代码展示：

config---SpringConfig

package com.jt.demo1.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.jt.demo1")
public class SpringConfig {

}

service--Uservice

package com.jt.demo1.userservice;

public interface UserService {
    void addUser();
    void deleteUser();
}

service--UserviceImpl

package com.jt.demo1.userservice;

import org.springframework.stereotype.Service;


@Service
public class UserServiceImpl implements UserService{
    @Override
    public void addUser(){
        System.out.println("百味书屋");
    }

    public void deleteUser(){
        System.out.println("三维立体");
    }
}

准备一个测试类，放到和和三个包同级中

package com.jt.demo1;

import com.jt.demo1.config.SpringConfig;
import com.jt.demo1.porxy.JDKProxy;
import com.jt.demo1.userservice.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;



public class SpringTx {
    public static void main(String[] args) {

        ApplicationContext context=
                new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean(UserService.class);
        System.out.println(userService.getClass());

        UserService proxy = (UserService) JDKProxy.getProxy(userService);
        System.out.println(proxy.getClass());

        proxy.addUser();
        proxy.deleteUser();



    }
}

效果展示