This article brings you relevant knowledge about java, which mainly introduces the design patterns related to performance. Most design patterns are just a way of organizing code, and only part of the design Patterns are related to performance, including proxy mode, singleton mode, flyweight mode, prototype mode, etc. Let’s take a look at them together. I hope it will be helpful to everyone.
Recommended study: "java Video Tutorial"
The structure of the code has an important impact on the overall performance of the application. Code with excellent structure can avoid many potential performance problems and play a huge role in the scalability of the code; code with clear structure and clear layers can also help you find bottlenecks in the system and carry out special optimization.
Design pattern is a summary of common development techniques. It allows programmers to communicate problems in a more professional and convenient way.
In fact, most design patterns do not increase the performance of the program, it is just a way of organizing the code. In this article, we will give examples one by one to explain several design patterns related to performance, including proxy mode, singleton mode, flyweight mode, prototype mode, etc.
Proxy mode (Proxy) can control access to an object through a proxy class.
There are two main modes for implementing dynamic proxies in Java: one is to use JDK, and the other is to use CGLib. Among them, the JDK method is interface-oriented, and the main related classes are InvocationHandler and Proxy; CGLib can proxy ordinary classes, and the main related classes are MethodInterceptor and Enhancer.
The interview frequency for this knowledge point is very high.
package cn.wja.proxy.cglibproxy;import org.springframework.cglib.proxy.MethodInterceptor;import org.springframework.cglib.proxy.MethodProxy;import java.lang.reflect.Method;public class CglibInterceptor implements MethodInterceptor { @Override public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { return methodProxy.invokeSuper(o, objects); }}
package cn.wja.proxy.cglibproxy;import cn.wja.proxy.jdkproxy.Target;import cn.wja.proxy.jdkproxy.TargetImpl;import org.springframework.cglib.proxy.Enhancer;public class CglibFactory { public static Target newInstance() { Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(TargetImpl.class); enhancer.setCallback(new CglibInterceptor()); return (Target) enhancer.create(); } public static void main(String[] args) { Target target = newInstance(); System.out.println(target.targetMetod(4)); }}
package cn.wja.proxy.jdkproxy;public interface Target { int targetMethod(int i);}
package cn.wja.proxy.jdkproxy;public class TargetImpl implements Target { @Override public int targetMethod(int i) { return i * i; }}
package cn.wja.proxy.jdkproxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;public class JdkInvocationHandler implements InvocationHandler { private Target target; public JdkInvocationHandler(Target target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //before Object object = method.invoke(target, args); //after return object; }}
package cn.wja.proxy.jdkproxy;import java.lang.reflect.Proxy;public class JdkFactory { public static Target newInstance(Target target) { Object object = Proxy.newProxyInstance(JdkInvocationHandler.class.getClassLoader(), new Class>[]{Target.class}, new JdkInvocationHandler(target)); return Target.class.cast(object); } public static void main(String[] args) { Target t = new TargetImpl(); Target target = newInstance(t); System.out.println(target.targetMethod(4)); }}
The following are the JMH test results of JDK mode and CGLib mode proxy speed:
Benchmark | Mode | Cnt | Score | Error | Units |
---|---|---|---|---|---|
ProxyBenchmark.cglib | thrpt | 10 | 78499.580 | ±1771.148 | ops/ms |
ProxyBenchmark.jdk | thrpt | 10 | 88948.858 | ±814.360 | ops/ms |
The JDK version I am using now is 1.8. You can see that the speed of CGLib is not that fast (rumored to be 10 times higher). In comparison, It even slows down slightly.
Let’s take a look at the proxy creation speed. The results are as follows. It can be seen that in terms of proxy class initialization, the throughput of JDK is twice that of CGLib.
Benchmark | Mode | Cnt | Score | Error | Units |
---|---|---|---|---|---|
thrpt | 10 | 7281.487 | ± 1339.779 | ops/ms | |
thrpt | 10 | ##15612.467± 268.362 | ops/ms |
The above is the detailed content of Let’s talk about performance-related design patterns in Java. For more information, please follow other related articles on the PHP Chinese website!