First of all, let’s briefly explain what the proxy mode is.

Proxy is a design pattern that provides another way to access the target object; that is, access the target object through the proxy object. The advantage of this is that it can enhance the target object based on the implementation of the target object. Additional functional operations, that is, extending the functions of the target object.
An idea in programming is used here: do not modify the code or methods that have been written by others at will. If you need to modify it, you can extend it through a proxy. Method

Give an example to illustrate the role of an agent: Suppose we want to invite a star, then we do not directly contact the star, but contact the star's agent to achieve the same purpose. The star is a target object , he only needs to be responsible for the program at the event, and other trivial matters are left to his agent (broker) to solve. This is an example of agency thinking in reality.

The diagram is as follows:

The key points of the proxy mode are: proxy object and target object. The proxy object is an extension of the target object and will call the target object

1.1. Static Proxy

When using a static proxy, you need to define an interface or a parent class. The proxy object and the proxy object implement the same interface or inherit the same parent class.

The following is a case to explain :
Simulate the save action, define an interface for the save action: IUserDao.java, and then the target object implements the method UserDao.java of this interface. At this time, if you use the static proxy method, you need to in the proxy object (UserDaoProxy.java) Also implements the IUserDao interface. When calling, call the target object by calling the method of the proxy object.
It should be noted that the proxy object and the target object must implement the same interface, and then call the method of the target object by calling the same method.

Code example:
Interface:IUserDao.java

/**
 * 接口
 */public interface IUserDao {    void save();
}

Target object:UserDao.java

/**
 * 接口實現(xiàn)
 * 目標(biāo)對象
 */public class UserDao implements IUserDao {    public void save() {
        System.out.println("----已經(jīng)保存數(shù)據(jù)!----");
    }
}

Proxy object:UserDaoProxy.java

/**
 * 代理對象,靜態(tài)代理
 */public class UserDaoProxy implements IUserDao{    //接收保存目標(biāo)對象
    private IUserDao target;    public UserDaoProxy(IUserDao target){        this.target=target;
    }    public void save() {
        System.out.println("開始事務(wù)...");
        target.save();//執(zhí)行目標(biāo)對象的方法
        System.out.println("提交事務(wù)...");
    }
}

(Learning video sharing: java video tutorial)

Test class:App.java

/**
 * 測試類
 */public class App {    public static void main(String[] args) {        //目標(biāo)對象
        UserDao target = new UserDao();        //代理對象,把目標(biāo)對象傳給代理對象,建立代理關(guān)系
        UserDaoProxy proxy = new UserDaoProxy(target);

        proxy.save();//執(zhí)行的是代理的方法
    }
}

Static agent summary:
1. It can be done without modifying the target Under the premise of the function of the object, the target function is expanded.
2. Disadvantages:

Because the proxy object needs to implement the same interface as the target object, there will be many proxy classes, too many classes. At the same time, once When adding methods to the interface, both the target object and the proxy object must be maintained.

How to solve the shortcomings of static proxy? The answer is that you can use dynamic proxy method

1.2. Dynamic proxy

Dynamic proxy has the following characteristics:
1. Proxy object does not need to implement the interface
2. The generation of proxy object is to use the API of JDK to dynamically build the proxy object in the memory (we need to specify the creation of proxy object /The type of interface implemented by the target object)
3. Dynamic proxy is also called: JDK proxy, interface proxy

API for generating proxy objects in JDK
The package where the proxy class is located: java.lang.reflect .Proxy
JDK only needs to use the newProxyInstance method to implement the proxy, but this method needs to receive three parameters. The complete writing method is:

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )

Note that this method is a static method in the Proxy class and receives The three parameters are:

ClassLoader loader,: specifies the current target object to use the class loader, and the method of obtaining the loader is fixed

Class[] interfaces,: target The type of interface implemented by the object, use generics to confirm the type

InvocationHandler h: event processing, when executing the method of the target object, the method of the event processor will be triggered, and the method of the currently executed target object will be used as a parameter Pass in

code example:
interface class IUserDao.java and interface implementation class. The target object UserDao is the same without modification. On this basis, add a proxy factory class (ProxyFactory.java) , write the proxy class in this place, and then first establish the connection between the target object and the proxy object in the test class (the code that needs to use the proxy), and then use the method of the same name in the proxy object

Agent factory class: ProxyFactory.java

/**
 * 創(chuàng)建動態(tài)代理對象
 * 動態(tài)代理不需要實現(xiàn)接口,但是需要指定接口類型
 */public class ProxyFactory{    //維護一個目標(biāo)對象
    private Object target;    public ProxyFactory(Object target){        this.target=target;
    }   //給目標(biāo)對象生成代理對象
    public Object getProxyInstance(){        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),                new InvocationHandler() {                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("開始事務(wù)2");                        //執(zhí)行目標(biāo)對象方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("提交事務(wù)2");                        return returnValue;
                    }
                }
        );
    }

}

Test class: App.java

/**
 * 測試類
 */public class App {    public static void main(String[] args) {        // 目標(biāo)對象
        IUserDao target = new UserDao();        // 【原始的類型 class cn.itcast.b_dynamic.UserDao】
        System.out.println(target.getClass());        // 給目標(biāo)對象，創(chuàng)建代理對象
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();        // class $Proxy0   內(nèi)存中動態(tài)生成的代理對象
        System.out.println(proxy.getClass());        // 執(zhí)行方法   【代理對象】
        proxy.save();
    }
}

Summary:
The proxy object does not need to implement the interface, but the target object must implement the interface, otherwise dynamic proxy cannot be used

1.3.Cglib proxy

The above static proxy and dynamic proxy modes require the target object to be a target object that implements an interface, but sometimes the target object is just a separate object and does not implement any interface, at this time you can use the target object subclass to implement the proxy. This method is called: Cglib proxy

Cglib代理,也叫作子類代理,它是在內(nèi)存中構(gòu)建一個子類對象從而實現(xiàn)對目標(biāo)對象功能的擴展.

JDK的動態(tài)代理有一個限制,就是使用動態(tài)代理的對象必須實現(xiàn)一個或多個接口,如果想代理沒有實現(xiàn)接口的類,就可以使用Cglib實現(xiàn).Cglib是一個強大的高性能的代碼生成包,它可以在運行期擴展java類與實現(xiàn)java接口.它廣泛的被許多AOP的框架使用,例如Spring AOP和synaop,為他們提供方法的interception(攔截)Cglib包的底層是通過使用一個小而塊的字節(jié)碼處理框架ASM來轉(zhuǎn)換字節(jié)碼并生成新的類.不鼓勵直接使用ASM,因為它要求你必須對JVM內(nèi)部結(jié)構(gòu)包括class文件的格式和指令集都很熟悉.

Cglib子類代理實現(xiàn)方法:
1.需要引入cglib的jar文件,但是Spring的核心包中已經(jīng)包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可.
2.引入功能包后,就可以在內(nèi)存中動態(tài)構(gòu)建子類
3.代理的類不能為final,否則報錯
4.目標(biāo)對象的方法如果為final/static,那么就不會被攔截,即不會執(zhí)行目標(biāo)對象額外的業(yè)務(wù)方法.

代碼示例:
目標(biāo)對象類:UserDao.java

/**
 * 目標(biāo)對象,沒有實現(xiàn)任何接口
 */public class UserDao {    public void save() {
        System.out.println("----已經(jīng)保存數(shù)據(jù)!----");
    }
}

Cglib代理工廠:ProxyFactory.java

/**
 * Cglib子類代理工廠
 * 對UserDao在內(nèi)存中動態(tài)構(gòu)建一個子類對象
 */public class ProxyFactory implements MethodInterceptor{    //維護目標(biāo)對象
    private Object target;    public ProxyFactory(Object target) {        this.target = target;
    }    //給目標(biāo)對象創(chuàng)建一個代理對象
    public Object getProxyInstance(){        //1.工具類
        Enhancer en = new Enhancer();        //2.設(shè)置父類
        en.setSuperclass(target.getClass());        //3.設(shè)置回調(diào)函數(shù)
        en.setCallback(this);        //4.創(chuàng)建子類(代理對象)
        return en.create();

    }    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("開始事務(wù)...");        //執(zhí)行目標(biāo)對象的方法
        Object returnValue = method.invoke(target, args);

        System.out.println("提交事務(wù)...");        return returnValue;
    }
}

測試類:

/**
 * 測試類
 */public class App {    @Test
    public void test(){        //目標(biāo)對象
        UserDao target = new UserDao();        //代理對象
        UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();        //執(zhí)行代理對象的方法
        proxy.save();
    }
}

在Spring的AOP編程中:
如果加入容器的目標(biāo)對象有實現(xiàn)接口,用JDK代理
如果目標(biāo)對象沒有實現(xiàn)接口,用Cglib代理

相關(guān)推薦：java入門教程

The above is the detailed content of What are the three proxy modes of java?. For more information, please follow other related articles on the PHP Chinese website!