动态代理

在当今的网络世界中，代理IP成为了一个热门话题。它可能让你暗藏实在的IP地址，并且可能在特定的IP地址上进行网络流动。那么，如何应用代理IP来批改网络IP地址呢？上面就为大家具体介绍。 首先，咱们须要理解什么是代理IP。简略来说，代理IP就是一种直达服务器，当咱们应用代理IP时，网络申请会先通过代理服务器，再连贯到指标网站。这样，指标网站接管到的信息就会是代理服务器的IP地址，而非咱们实在的IP地址。 那么，如何应用代理IP来批改网络IP地址呢？ 寻找可用的代理IP资源首先，咱们须要寻找可用的代理IP资源。能够通过搜索引擎或者专门的代理IP服务网站来寻找。在抉择代理IP时，须要留神以下几点： 代理IP的匿名性：抉择可能暗藏实在IP地址的代理IP。代理IP的速度：抉择速度快、稳固的代理IP。代理IP的地区：能够依据需要抉择不同地区的代理IP。抉择适合的代理IP软件在抉择好代理IP资源后，咱们须要抉择一款适合的代理IP软件。市面上有很多代理IP软件可供选择，如“Proxifier”、“Proxyee-down”等。在抉择软件时，须要留神以下几点： 软件是否反对HTTP、SOCKS等协定。软件是否具备主动捕捉网络申请的性能。软件是否具备自动测试可用性的性能。设置代理IP软件在抉择好代理IP软件后，咱们须要依据软件的设置向导进行设置。一般来说，须要输出代理服务器的IP地址和端口号等信息。在设置实现后，软件会自动测试代理服务器的可用性。 应用代理IP进行网络流动在设置好代理IP软件后，咱们就能够应用代理IP进行网络流动了。在应用时，须要留神以下几点： 在应用代理IP时，不要同时应用其余VPN服务，免得造成网络抵触。在应用代理IP时，须要留神爱护个人信息和账户平安。在应用代理IP时，须要留神恪守法律法规和指标网站的应用协定。总之，应用代理IP来批改网络IP地址是一种十分实用的办法。通过这种办法，咱们能够暗藏实在的IP地址，爱护个人隐私和平安。然而，在应用时也须要留神一些问题，免得造成不必要的麻烦。

爬虫代理IP资源获取的常见问题包含以下几个方面： 代理IP的品质和稳定性：获取到的代理IP可能存在品质问题，如IP被封禁、生效、速度慢等，这会影响爬虫程序的运行效率和稳定性。此外，代理服务器的稳定性也是一个须要思考的问题，如果代理服务器频繁宕机或网络不稳固，也会导致爬虫程序无奈失常运行。代理IP的数量和散布：获取到的代理IP数量和散布也是一个须要思考的问题。如果代理IP数量有余或散布不平衡，可能会导致爬虫程序无奈笼罩到指标网站的所有内容，或者须要破费更多的工夫和资源来实现爬取工作。代理IP的老本：获取代理IP的老本也是一个须要思考的问题。一些高质量的代理IP资源可能须要领取肯定的费用，而收费的代理IP资源可能存在更多的品质问题和稳定性问题。因而，须要依据理论状况综合思考代理IP的老本和效益。代理IP的合法性和安全性：在应用代理IP时，须要留神其合法性和安全性。一些代理IP可能存在守法或进犯别人权利的问题，应用这些代理IP可能会导致法律危险和道德风险。此外，代理IP的应用也须要留神爱护个人信息和隐衷，防止泄露敏感信息或蒙受网络攻击。为了解决这些问题，能够采取一些措施，如应用高质量的代理IP供应商、定期检测和更新代理IP、设置正当的代理IP轮换策略、增加随机延时等。同时，也须要留神恪守法律法规和道德规范，流冠确保代理IP的合法性和安全性。

在互联网时代，手机曾经成为了咱们生存中必不可少的工具。然而，有时候咱们须要更换手机的IP地址，比方在进行网络测试、防止IP被封禁等状况下。那么，如何更换手机的IP地址呢？更换IP地址后对网速有没有影响呢？本文将为您具体解答这些问题。 一、更换手机IP地址的办法 应用手机流量更换IP地址应用手机流量上网时，每次断开网络再从新连贯，手机都会获取一个新的IP地址。这种办法尽管能够更换IP地址，但比拟麻烦，而且频繁断开网络会影响手机的失常应用。 应用VPN更换IP地址VPN是一种能够在公共网络上建设加密通道的技术，通过这种技术能够使手机连贯到国外的服务器，从而实现更换IP地址的目标。应用VPN更换IP地址比拟不便，但须要留神抉择牢靠的VPN服务商，以确保网络安全。 应用ADSL拨号更换IP地址如果您应用的是ADSL拨号上网，能够尝试断开网络再从新连贯。在每次拨号时，运营商会调配一个新的IP地址给您的手机。不过须要留神的是，这种办法须要您在每次更换IP地址时从新进行ADSL拨号，比拟麻烦且影响手机的失常应用。 二、更换IP地址后对网速的影响 更换手机IP地址后，对网速的影响次要取决于您抉择的更换办法。应用手机流量更换IP地址对网速根本没有影响，因为这种办法的操作比较简单，不会对网络环境造成太大的烦扰。而应用VPN或ADSL拨号更换IP地址可能会对网速产生肯定的影响，因为这些办法须要建设加密通道或从新拨号，会耗费更多的网络资源。尤其是在网络拥挤的状况下，更换IP地址可能会减轻网络的累赘，从而影响网速。 不过总体来说，更换手机IP地址对网速的影响并不大，除非您频繁更换IP地址或者在网络拥挤的状况下更换IP地址。如果您须要频繁更换IP地址，倡议抉择稳固牢靠的办法，并确保您的网络环境良好。 三、总结 更换手机IP地址的办法有多种，其中应用VPN和ADSL拨号是比拟罕用的办法。更换IP地址后对网速的影响取决于您抉择的更换办法，应用手机流量更换IP地址对网速根本没有影响，而应用VPN或ADSL拨号更换IP地址可能会对网速产生肯定的影响。在抉择更换IP地址的办法时，须要综合思考操作简便性、安全性和网络环境等因素。如果您须要频繁更换IP地址，倡议抉择稳固牢靠的办法，并确保您的网络环境良好。

动静 IP 地址是一种公共 IP 地址，容许在必要时进行更改。网络的每个连贯都会主动调配一个动静 IP 地址。为此，ISP 将应用DHCP 服务器。动静 IP 地址的劣势1.老本和动态 IP 地址相比，动静 IP 地址更具老本效益。通常与 ISP 相干的老本较低，因为它是主动配置的。这使得动静 IP 地址成为一种经济的抉择。 平安因为在动静 IP 中常常调配新地址，因而应用它时相干的危险较小。攻击者更难瞄准您的网络。此外，还能够施行 VPN 等额定的安全措施来防止跟踪。3.配置动静 IP 地址的整个配置由 DHCP 服务器负责。必要时，DHCP 服务器会一个接一个地调配 IP 地址。用户在配置中没有任何角色。灵活性在施行方面，动静 IP 地址更加灵便。设置和治理动静 IP 地址变得更加容易。此外，动静 IP 地址能够多次重复应用。如果调配有动静 IP 地址的设施偏向于断开连接，则同一地址能够被另一台设施重复使用。设施数量每当在动静 IP 中增加 nee 设施时，都会为每个设施调配一个新地址。在某些状况下，会重复使用雷同的 IP 地址。因而，避免了地址抵触的问题。动静 IP 地址的劣势1.老本与动态 IP 地址相比，动静 IP 地址更具老本效益。通常与 ISP 相干的老本较低，因为它是主动配置的。这使得动静 IP 地址成为一种经济的抉择。平安因为在动静 IP 中常常调配新地址，因而应用它时相干的危险较小。攻击者更难瞄准您的网络。此外，还能够施行 VPN 等额定的安全措施来防止跟踪。3.配置动静 IP 地址的整个配置由 DHCP 服务器负责。必要时，DHCP 服务器会一个接一个地调配 IP 地址。用户在配置中没有任何角色。灵活性在施行方面，动静 IP 地址更加灵便。设置和治理动静 IP 地址变得更加容易。此外，动静 IP 地址能够多次重复应用。如果调配有动静 IP 地址的设施偏向于断开连接，则同一地址能够被另一台设施重复使用。设施数量每当在动静 IP 中增加 nee 设施时，都会为每个设施调配一个新地址。在某些状况下，会重复使用雷同的 IP 地址。因而，避免了地址抵触的问题。流冠动静IP地址绝对于动态IP地址具备更加灵便、节省成本、更平安的长处。

代理IP是指在网络中用来暗藏实在IP地址的服务器，它充当了客户端与网站服务器之间的中介。当客户端发出请求时，申请会先发送到代理IP，再由代理IP转发到指标服务器。在这个过程中，指标服务器看到的是代理IP地址，而不是客户端的IP地址。这样一来，就会暗藏客户端的实在IP地址，达到匿名的目标。 随着网络的迅速倒退，代理IP曾经成为许多业务和生存场景中不可短少的工具。而代理IP也依据不同的特色分为了许多品种，明天就带大家理解一下对于动态代理IP和动静代理IP的区别。 动态代理 IP 和动静代理 IP 是两种不同类型的代理服务器，它们在工作原理和利用场景方面有所区别： 动态代理IP：也叫作长效IP，是一种固定的代理服务器，也就是说，它的 IP 地址是固定不变的。 动静代理IP：也叫作短效IP，是一种可变的代理服务器，它的 IP 地址是会发生变化的。 通常状况下，动态代理IP会被用于须要24小时放弃在线稳固IP的业务；而动静代理IP则实用于对于IP变动不敏感、要求高效连贯的业务。 动态代理IP与动静代理IP具体利用场景有以下这几种： 动态代理IP： 1、跨境电商经营 因为跨境电商平台的机制，如Amazon、eBay等跨境电商卖家往往须要应用动态代理IP来冲破网络限度；或多账号经营时，每个账号应用动态代理IP可能避免账号关联。 2、社交平台养号 如果须要每天都登录Facebook、tiktok、ins之类的社交平台进行养号，应用动态代理IP可能使账号环境更加平安稳固，发帖、更新动静时权重也会更高。 3、广告投放引流 当商家在社交媒体平台上做站外引流广告投放时能够应用流冠动态IP，因为广告投放是长线工作，应用动态代理IP会让账号更加稳固平安，升高账号被封禁的危险。 动静代理IP： 1、爬虫收集材料 网络爬虫在运行时对同一个网页进行高频率的拜访会触发反爬虫机制，会被网页标记甚至拉黑。因而须要应用动静IP来模仿不同的实在用户，避免被网页拉黑。 2、秒杀抢购商品 应用多个账号抢购限量商品时，如果用户在雷同的IP地址应用多个账户，会被检测到并有封号的危险，应用动静IP能够满足抢购时多账户应用不同IP的需要。 3、社交平台推广 海内热门的社交平台的多账号推广也离不开动静IP，利用不同IP注册不同的账号相互浏览、点赞、评论等，能够进步账号的互动率，晋升账号权重。 其实，代理IP最次要还是要依照业务需要来抉择，心愿对大家有肯定帮忙哦！

马上春节啦，没啥事件了，抽空整顿了下Spring源码。前两天整顿了Spring的Ioc，前面就开始Aop了。看能更到哪就更到哪吧，不定期更新～～～～反正也没人看本期做一个提前准备，钻研下JDK动静代理和Cglib。看完还是搞不明确，来砍我。 JDK动静代理测试代码public interface Test1 { void sayHello();}public interface Test2 { void sayBye();}public class TargetInterfaceImpl implements Test1,Test2{ @Override public void sayHello() { System.out.println("sayHello"); } @Override public void sayBye() { System.out.println("sayBye"); }}public class JdkInvocation { public static void main(String[] args) { //须要代理的对象 Test1 t=new TargetInterfaceImpl(); //自定义Invocation的实现 InvocationHandler invokeHandler= (proxy, method, args1) -> { method.invoke(t, args1); return null; }; Test1 targetInterface=(Test1)Proxy.newProxyInstance(JdkInvocation.class.getClassLoader(),TargetInterfaceImpl.class.getInterfaces(),invokeHandler); targetInterface.sayHello(); byte[] bytes = ProxyGenerator.generateProxyClass("aaaaa", new Class[]{targetInterface.getClass()}); try( FileOutputStream fos =new FileOutputStream(new File("jdk.class")) ){ fos.write(bytes); fos.flush(); }catch (Exception e){ e.printStackTrace(); } }}源码剖析JDK动静代理次要就是实现InvocationHandler，重写invoke办法，交给Proxy.newProxyInstance生成代理对象。ProxyGenerator.generateProxyClass为获取字节码文件，并打印，上面的能够疏忽，本次次要剖析的就是Proxy.newProxyInstance。 ...

前言本篇文章将剖析Mybatis在配置文件加载的过程中，如何解析映射文件中的SQL语句以及每条SQL语句如何与映射接口的办法进行关联。在看该局部源码之前，须要具备JDK动静代理的相干常识，如果该局部不是很理解，能够先看Java根底-动静代理学习JDk动静代理的原理。 注释一. 映射文件/映射接口的配置给出Mybatis的配置文件mybatis-config.xml如下所示。 <?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration> <settings> <setting name="useGeneratedKeys" value="true"/> </settings> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/test?characterEncoding=utf-8&amp;serverTimezone=UTC&amp;useSSL=false"/> <property name="username" value="root"/> <property name="password" value="root"/> </dataSource> </environment> </environments> <mappers> <package name="com.mybatis.learn.dao"/> </mappers></configuration>上述配置文件的mappers节点用于配置映射文件/映射接口，mappers节点下有两种子节点，标签别离为<mapper>和<package>，这两种标签的阐明如下所示。 标签阐明<mapper>该标签有三种属性，别离为resource，url和class，且在同一个<mapper>标签中，只能设置这三种属性中的一种，否则会报错。resource和url属性均是通过通知Mybatis映射文件所在的地位门路来注册映射文件，前者应用相对路径（绝对于classpath，例如"mapper/BookMapper.xml"），后者应用绝对路径。class属性是通过通知Mybatis映射文件对应的映射接口的全限定名来注册映射接口，此时要求映射文件与映射接口同名且同目录。<package>通过设置映射接口所在包名来注册映射接口，此时要求映射文件与映射接口同名且同目录。依据上表所示，示例中的配置文件mybatis-config.xml是通过设置映射接口所在包名来注册映射接口的，所以映射文件与映射接口须要同名且目录，如下图所示。 具体的起因会在下文的源码剖析中给出。 二. 加载映射文件的源码剖析在Mybatis源码-配置加载中曾经晓得，应用Mybatis时会先读取配置文件mybatis-config.xml为字符流或者字节流，而后通过SqlSessionFactoryBuilder基于配置文件的字符流或字节流来构建SqlSessionFactory。在这整个过程中，会解析mybatis-config.xml并将解析后果丰盛进Configuration，且Configuration在Mybatis中是一个单例，无论是配置文件的解析后果，还是映射文件的解析后果，亦或者是映射接口的解析后果，最终都会存在Configuration中。接着Mybatis源码-配置加载这篇文章开端持续讲，配置文件的解析产生在XMLConfigBuilder的parseConfiguration()办法中，如下所示。 private void parseConfiguration(XNode root) { try { propertiesElement(root.evalNode("properties")); Properties settings = settingsAsProperties(root.evalNode("settings")); loadCustomVfs(settings); loadCustomLogImpl(settings); typeAliasesElement(root.evalNode("typeAliases")); pluginElement(root.evalNode("plugins")); objectFactoryElement(root.evalNode("objectFactory")); objectWrapperFactoryElement(root.evalNode("objectWrapperFactory")); reflectorFactoryElement(root.evalNode("reflectorFactory")); settingsElement(settings); environmentsElement(root.evalNode("environments")); databaseIdProviderElement(root.evalNode("databaseIdProvider")); typeHandlerElement(root.evalNode("typeHandlers")); //依据mappers标签的属性，找到映射文件/映射接口并解析 mapperElement(root.evalNode("mappers")); } catch (Exception e) { throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e); }}如上所示，在解析Mybatis的配置文件时，会依据配置文件中的<mappers>标签的属性来找到映射文件/映射接口并进行解析。如下是mapperElement()办法的实现。 ...

动静代理相比于动态代理是生成代理类和实现类的class文件，动静代理则是动静生成字节码加载到程序中。而且，相比于动态代理须要针对每一个接口去独自写一个代理类，动静代理只须要一个代理类就能够实现（依据传入的被代理类判断） JDK动静代理public interface Player { void getGamePoints();}public class ADavids implements Player { private String name = "Anthony Davids"; public void getGamePoints() { System.out.println(name + " get 45 points!"); } }public class ProxyHandler implements InvocationHandler { private Object object; public ProxyHandler(Object object){ this.object = object; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println(method.getName()); System.out.println("The player is Coming-------" ); Object obj = method.invoke(object,args); System.out.println("THE END---------------"); return obj; }}public class Test { public static void main(String[] args) { //JDK动静代理 ADavids aDavids = new ADavids(); Object obj = Proxy.newProxyInstance(aDavids.getClass().getClassLoader(),aDavids.getClass().getInterfaces(),new ProxyHandler(aDavids)); Player proxyAfterObj = (Player)obj; proxyAfterObj.getGamePoints(); }}打印后果为：getGamePointsThe player is Coming-------Anthony Davids get 45 points!THE END---------------CGLIB动静代理public class EspnNews { public void playnews(){ System.out.println("AD GET 45 PTS TODAY"); }}public class InterceptorTv implements MethodInterceptor { public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { System.out.println("This dailynew -------"); Object obj = methodProxy.invokeSuper(o,objects); System.out.println("Play End -------"); return obj; }}public class ProxyNews { public static Object getProxyObj(Class clazz){ Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(clazz); enhancer.setCallback(new InterceptorTv()); return enhancer.create(); }}public class Test { public static void main(String[] args) { //CGlib动静代理 EspnNews espnNews = (EspnNews) ProxyNews.getProxyObj(EspnNews.class); espnNews.playnews(); }}打印后果为：This dailynew -------AD GET 45 PTS TODAYPlay End -------

接口类： public interface Service { public void print();}实现类 package com.tao.proxy;public class ServiceImpl implements Service { @Override public void print() { System.out.println("hello"); }}代理类 public class TaoInvoker implements InvocationHandler { private Object object ; public TaoInvoker() { } public TaoInvoker(Object object) { this.object = object; } public Object newProxy(Object target){ this.object = target; return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("加强代码"); return method.invoke(object, args); } public static void main(String[] args) { Service service = new ServiceImpl(); Service o = (Service) new TaoInvoker().newProxy(new ServiceImpl()); o.print(); }}加强代码hello

代理模式代理模式给某一个对象提供一个代理对象，并由代理对象管制对原对象的援用。 动态代理代理类HelloProxypublic class HelloProxy implements HelloInterface{ private HelloInterface helloInterface = new Hello(); @Override public void sayHello() { System.out.println("Before invoke sayHello" ); helloInterface.sayHello(); System.out.println("After invoke sayHello"); }}接口HelloInterfacepublic interface HelloInterface { void sayHello();}继承接口的办法Hellopublic class Hello implements HelloInterface{ @Override public void sayHello() { System.out.println("Hello Zero!"); }}主函数public class Main { public static void main(String[] args) { HelloProxy helloProxy = new HelloProxy(); helloProxy.sayHello(); }}运行后果Before invoke sayHelloHello Zero!After invoke sayHello应用动态代理实现了对一个类的代理操作。然而动态代理也有毛病：因为代理只能为一个类服务，如果须要代理的类很多，那么就须要编写大量的代理类，比拟繁琐。 动静代理利用反射机制在运行时创立代理类。 接口和继承接口的办法不变。 ...

作者：易哥 链接：https://zhuanlan.zhihu.com/p/... 起源：知乎 著作权归作者所有。商业转载请分割作者取得受权，非商业转载请注明出处。 1 动静代理动静代理的实现形式罕用的有两种： 反射实现：基于反射实现，指标对象必须要有接口。生成的代理类是接口的一个实现类Cglib实现：基于字节码实现，效率稍低，但指标对象不须要有接口。生成的代理类是指标类的子类，因而指标类不能是final的。2 背景介绍 在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过应用这个类和接口就能够生成动静代理对象，只能针对接口做代理。 接口和指标类没有任何变动，只不过为了减少难度，咱们减少了返回值。 接口如下，除了减少了办法的返回值外无任何变动： 指标类如下，无任何变动： 2 反射调用办法接下来，咱们应用JDK实现动静代理，对于代理类只须要实现InvocationHandler接口即可，并且要实现其中的invoke（）办法。 invoke（）中须要传入指标对象、指标对象的办法、调用指标所需的参数，传入后，就会间接调用指定对象的指定办法了。 咱们应用举例： 咱们只有创立一个ProxyHandler对象，间接调用invoke办法，传入其中所须要的对象、办法、参数，便能够执行咱们写好的invoke办法，并且invoke中还能够调用指定对象的指定办法。这种办法非常灵活，ProxyHandler建设后，调用invoke办法时，能够传入任何对象、任何办法，十分自在。 这种操作只是通过反射调用的指定对象的指定办法，并没有应用代理。然而能够用它来实现动静代理。咱们只有生成一个代理对象，接口所有的操作都由代理对象来实现。其中，代理对象中再通过这种反射的形式去调用指标对象即可了。 3 动静代理在应用动静代理时，ProxyHandler须要稍加革新，即在构造方法中传入指标对象。然而这里要留神的是，与动态代理不同，这里的指标对象的类型是任意的，因而同一个ProxyHandler能够用来代理不同的指标对象。 在应用时，如下： 首先，咱们定义了被代理的类的实例，并且传给了proxyHandler。而后，咱们咱们间接调用了Proxy的静态方法newProxyInstance生成了一个接口的实例，这个实例就是代理（而且它晓得它代理的是user对象，初始化时曾经传给它了）。 而后，间接对这个实例调用办法就能够了，对这个接口调用办法，就相当于执行了invoke中的操作，输入如下： pre wordshello Lilypost words留神，在这种实现中，指标类target是在初始化时写死，并且在invoke时间接调用的，如果在invoke中间接调用传来的proxy对象，则会引发循环调用，造成死循环。 咱们查看下Proxy类中的静态方法，newProxyInstance办法： 该办法用来返回指定接口的一个代理类实例。 输出参数有： 生成代理类实例的classLoader；要满足的接口；代理类的处理器，即具体的实现。这样就指明了用哪个处理器解决哪个接口中的操作，以及该对象如何生成进去。 生成的对象就是一个代理对象，就能够代理接口的操作了。

作者：易哥 链接：https://zhuanlan.zhihu.com/p/... 起源：知乎 著作权归作者所有。商业转载请分割作者取得受权，非商业转载请注明出处。 1 动静代理动静代理的实现形式罕用的有两种： 反射实现：基于反射实现，指标对象必须要有接口。生成的代理类是接口的一个实现类Cglib实现：基于字节码实现，效率稍低，但指标对象不须要有接口。生成的代理类是指标类的子类，因而指标类不能是final的。2 背景介绍 在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过应用这个类和接口就能够生成动静代理对象，只能针对接口做代理。 接口和指标类没有任何变动，只不过为了减少难度，咱们减少了返回值。 接口如下，除了减少了办法的返回值外无任何变动： 指标类如下，无任何变动： 2 反射调用办法接下来，咱们应用JDK实现动静代理，对于代理类只须要实现InvocationHandler接口即可，并且要实现其中的invoke（）办法。 invoke（）中须要传入指标对象、指标对象的办法、调用指标所需的参数，传入后，就会间接调用指定对象的指定办法了。 咱们应用举例： 咱们只有创立一个ProxyHandler对象，间接调用invoke办法，传入其中所须要的对象、办法、参数，便能够执行咱们写好的invoke办法，并且invoke中还能够调用指定对象的指定办法。这种办法非常灵活，ProxyHandler建设后，调用invoke办法时，能够传入任何对象、任何办法，十分自在。 这种操作只是通过反射调用的指定对象的指定办法，并没有应用代理。然而能够用它来实现动静代理。咱们只有生成一个代理对象，接口所有的操作都由代理对象来实现。其中，代理对象中再通过这种反射的形式去调用指标对象即可了。 3 动静代理在应用动静代理时，ProxyHandler须要稍加革新，即在构造方法中传入指标对象。然而这里要留神的是，与动态代理不同，这里的指标对象的类型是任意的，因而同一个ProxyHandler能够用来代理不同的指标对象。 在应用时，如下： 首先，咱们定义了被代理的类的实例，并且传给了proxyHandler。而后，咱们咱们间接调用了Proxy的静态方法newProxyInstance生成了一个接口的实例，这个实例就是代理（而且它晓得它代理的是user对象，初始化时曾经传给它了）。 而后，间接对这个实例调用办法就能够了，对这个接口调用办法，就相当于执行了invoke中的操作，输入如下： pre wordshello Lilypost words留神，在这种实现中，指标类target是在初始化时写死，并且在invoke时间接调用的，如果在invoke中间接调用传来的proxy对象，则会引发循环调用，造成死循环。 咱们查看下Proxy类中的静态方法，newProxyInstance办法： 该办法用来返回指定接口的一个代理类实例。 输出参数有： 生成代理类实例的classLoader；要满足的接口；代理类的处理器，即具体的实现。这样就指明了用哪个处理器解决哪个接口中的操作，以及该对象如何生成进去。 生成的对象就是一个代理对象，就能够代理接口的操作了。

作者：易哥 链接：https://zhuanlan.zhihu.com/p/... 起源：知乎 著作权归作者所有。商业转载请分割作者取得受权，非商业转载请注明出处。 1 动静代理动静代理的实现形式罕用的有两种： 反射实现：基于反射实现，指标对象必须要有接口。生成的代理类是接口的一个实现类Cglib实现：基于字节码实现，效率稍低，但指标对象不须要有接口。生成的代理类是指标类的子类，因而指标类不能是final的。2 背景介绍 在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过应用这个类和接口就能够生成动静代理对象，只能针对接口做代理。 接口和指标类没有任何变动，只不过为了减少难度，咱们减少了返回值。 接口如下，除了减少了办法的返回值外无任何变动： 指标类如下，无任何变动： 2 反射调用办法接下来，咱们应用JDK实现动静代理，对于代理类只须要实现InvocationHandler接口即可，并且要实现其中的invoke（）办法。 invoke（）中须要传入指标对象、指标对象的办法、调用指标所需的参数，传入后，就会间接调用指定对象的指定办法了。 咱们应用举例： 咱们只有创立一个ProxyHandler对象，间接调用invoke办法，传入其中所须要的对象、办法、参数，便能够执行咱们写好的invoke办法，并且invoke中还能够调用指定对象的指定办法。这种办法非常灵活，ProxyHandler建设后，调用invoke办法时，能够传入任何对象、任何办法，十分自在。 这种操作只是通过反射调用的指定对象的指定办法，并没有应用代理。然而能够用它来实现动静代理。咱们只有生成一个代理对象，接口所有的操作都由代理对象来实现。其中，代理对象中再通过这种反射的形式去调用指标对象即可了。 3 动静代理在应用动静代理时，ProxyHandler须要稍加革新，即在构造方法中传入指标对象。然而这里要留神的是，与动态代理不同，这里的指标对象的类型是任意的，因而同一个ProxyHandler能够用来代理不同的指标对象。 在应用时，如下： 首先，咱们定义了被代理的类的实例，并且传给了proxyHandler。而后，咱们咱们间接调用了Proxy的静态方法newProxyInstance生成了一个接口的实例，这个实例就是代理（而且它晓得它代理的是user对象，初始化时曾经传给它了）。 而后，间接对这个实例调用办法就能够了，对这个接口调用办法，就相当于执行了invoke中的操作，输入如下： pre wordshello Lilypost words留神，在这种实现中，指标类target是在初始化时写死，并且在invoke时间接调用的，如果在invoke中间接调用传来的proxy对象，则会引发循环调用，造成死循环。 咱们查看下Proxy类中的静态方法，newProxyInstance办法： 该办法用来返回指定接口的一个代理类实例。 输出参数有： 生成代理类实例的classLoader；要满足的接口；代理类的处理器，即具体的实现。这样就指明了用哪个处理器解决哪个接口中的操作，以及该对象如何生成进去。 生成的对象就是一个代理对象，就能够代理接口的操作了。

动静代理速查速记： 动静代理代理：原本应该本人做的事件，却请了他人来做，被请的人就是代理对象。举例：秋季回家买票让人代买动静代理：在程序运行过程中产生的这个对象而程序运行过程中产生对象其实就是咱们方才反射解说的内容，所以，动静代理其实就是通过反射来生成一个代理在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过应用这个类和接口就能够生成动静代理对象。JDK提供的代理只能针对接口做代理。咱们有更弱小的代理cglibProxy类中的办法创立动静代理类对象public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)最终会调用InvocationHandler的办法InvocationHandlerObject invoke(Object proxy,Method method,Object[] args)Proxy类中创立动静代理对象的办法的三个参数；ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载Interface对象的数组，示意的是我将要给我须要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就声称实现了该接口(多态)，这样我就能调用这组接口中的办法了InvocationHandler对象，示意的是当我这个动静代理对象在调用办法的时候，会关联到哪一个InvocationHandler对象上每一个动静代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当咱们通过代理对象调用一个办法的时候，这个办法的调用就会被转发为由InvocationHandler这个接口的invoke 办法来进行调用。InvocationHandler接口中invoke办法的三个参数：proxy:代表动静代理对象method:代表正在执行的办法args:代表调用指标办法时传入的实参Proxy.newProxyInstance创立的代理对象是在jvm运行时动静生成的一个对象，它并不是咱们的InvocationHandler类型，也不是咱们定义的那组接口的类型，而是在运行是动静生成的一个对象，并且命名形式都是这样的模式，以$结尾，proxy为中，最初一个数字示意对象的标号。System.out.println(u.getClass().getName());动静代理： package cn.itcast_06;/* * 用户操作接口 */public interface UserDao { public abstract void add(); public abstract void delete(); public abstract void update(); public abstract void find();}package cn.itcast_06;public class UserDaoImpl implements UserDao { @Override public void add() { System.out.println("增加性能"); } @Override public void delete() { System.out.println("删除性能"); } @Override public void update() { System.out.println("批改性能"); } @Override public void find() { System.out.println("查找性能"); }}package cn.itcast_06;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;public class MyInvocationHandler implements InvocationHandler { private Object target; // 指标对象 public MyInvocationHandler(Object target) { this.target = target; } @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; // 返回的是代理对象 }}package cn.itcast_06;import java.lang.reflect.Proxy;public class Test { public static void main(String[] args) { UserDao ud = new UserDaoImpl(); ud.add(); ud.delete(); ud.update(); ud.find(); System.out.println("-----------"); // 咱们要创立一个动静代理对象 // Proxy类中有一个办法能够创立动静代理对象 // public static Object newProxyInstance(ClassLoader loader,Class<?>[] // interfaces,InvocationHandler h) // 我筹备对ud对象做一个代理对象 MyInvocationHandler handler = new MyInvocationHandler(ud); UserDao proxy = (UserDao) Proxy.newProxyInstance(ud.getClass() .getClassLoader(), ud.getClass().getInterfaces(), handler); proxy.add(); proxy.delete(); proxy.update(); proxy.find(); }}

相熟的陌生人面试官如果问“请你谈谈你对Spring的了解”，预计很多人会脱口而出：IOC和AOP。IOC大略是大家对Spring最间接的印象，就是个大容器，装了很多bean，还会帮你做依赖注入。 IOC 然而对于AOP，很多人其实没有太多概念，一时不晓得Spring哪里用了AOP。如同事务用了切面，但具体又不理解。这样吧，我问你一个问题，我本人写了一个UserController，以及UserServiceImpl implements UserService，并且在UserController中注入Service层对象： @Autowiredprivate UserService userService;那么，这个userService肯定是咱们写的UserServiceImpl的实例吗？ 如果你听不懂我要问什么，阐明你自身对Spring的理解还是太局限于IOC。 实际上，Spring依赖注入的对象并不一定是咱们本人写的类的实例，也可能是userServiceImpl的代理对象。上面别离演示这两种状况： 注入userServiceImpl对象 注入的是UserServiceImpl类型 注入userServiceImpl的代理对象（CGLib动静代理） 注入的是CGLib动静代理生成的userServiceImpl的代理对象 为什么两次注入的对象不同？ 因为第二次我给UserServiceImpl加了@Transactional 注解。 此时Spring读取到这个注解，便晓得咱们要应用事务。而咱们编写的UserService类中并没有蕴含任何事务相干的代码。如果给你，你会怎么做？动静代理嘛！ 然而要用动静代理实现事务管理，还须要本人编写一个告诉类，并把告诉对象传入代理对象，告诉负责事务的开启和提交，并在代理对象外部调用指标对象同名办法实现业务性能。 咱们能想到的计划，Spring必定也晓得。同样地，Spring为了实现事务，也编写了一个告诉类，TransactionManager。利用动静代理创立代理对象时，Spring会把transactionManager织入代理对象，而后将代理对象注入到UserController。 所以咱们在UserController中应用的userService其实是代理对象，而代理对象才反对事务。 山寨AOP事务需要剖析理解了Spring事务的大抵流程后，咱们再来剖析一下本人如何编写一个山寨的AOP事务。 AOP事务，有两个概念：AOP和事务。 事务，大家曾经很相熟，这里次要讲讲什么是AOP。AOP，它是Aspect-Oriented Programming（面向切面编程）的英文缩写。什么是面向切面编程？有时间接介绍一个货色是什么，可能比拟难。然而一说到它是干嘛的，大家就立刻心领神会了。 咱们的零碎中，经常存在穿插业务，比方事务、日志等。UserService的method1要用到它，BrandService的method2也要用到它。一个穿插业务就是要切入零碎的一个方面。具体用代码展现就是： 这个切面，能够是日志，也能够是事务 穿插业务的编程问题即为面向切面编程。AOP的指标就是使穿插业务模块化。能够将切面代码移动到原始办法的四周： 原先不必AOP时，穿插业务间接写在办法外部的前后，用了AOP穿插业务写在办法调用前后。这与AOP的底层实现形式无关：动静代理其实就是代理对象调用指标对象的同名办法，并在调用前后加加强代码。不过这两种最终运行成果是一样的。 而所谓的模块化，我集体的了解是将切面代码做成一个可治理的状态。比方日志打印，不再是间接硬编码在办法中的零散语句，而是做成一个告诉类，通过告诉去执行切面代码。 所以，当初需要曾经很明确，咱们须要一个告诉类（TransactionManager）执行事务，一个代理工厂帮忙生成代理对象，而后利用动静代理将事务代码织入代理对象的各个办法中。 就好比上面三个Service，原先是没有开启事务的： 咱们心愿最终达到的成果是，我加了个@MyTransactional后，代理工厂给我返回一个代理对象： 代理工厂应用动静代理，为每一个指标对象创立一个代理对象 细节剖析： txManager其实是在指标对象test()办法的前后执行事务，而不是办法外部的前后 也就是说，代理对象办法 = 事务 + 指标对象办法。 另外，还有个辣手的问题：事务操作，必须应用同一个Connection对象。如何保障？第一次从数据源获取Connection对象并开启事务后，将它存入以后线程的ThreadLocal中，等到了DAO层，还是从ThreadLocal中取，这样就能保障开启事务和操作数据库应用的Connection对象是同一个。 开启事务后，Controller并不是间接调用咱们本人写的Service，而是Spring提供的代理对象 这就是事务的实现原理。 AOP事务具体代码实现ConnectionUtils工具类 package com.demo.myaopframework.utils;import org.apache.commons.dbcp.BasicDataSource;import java.sql.Connection;/** * 连贯的工具类，它用于从数据源中获取一个连贯，并且实现和线程的绑定 */public class ConnectionUtils { private ThreadLocal<Connection> tl = new ThreadLocal<Connection>(); private static BasicDataSource dataSource = new BasicDataSource(); //动态代码块,设置连贯数据库的参数 static{ dataSource.setDriverClassName("com.mysql.jdbc.Driver"); dataSource.setUrl("jdbc:mysql://localhost:3306/test"); dataSource.setUsername("root"); dataSource.setPassword("123456"); } /** * 获取以后线程上的连贯 * @return */ public Connection getThreadConnection() { try{ //1.先从ThreadLocal上获取 Connection conn = tl.get(); //2.判断以后线程上是否有连贯 if (conn == null) { //3.从数据源中获取一个连贯，并且存入ThreadLocal中 conn = dataSource.getConnection(); tl.set(conn); } //4.返回以后线程上的连贯 return conn; }catch (Exception e){ throw new RuntimeException(e); } } /** * 把连贯和线程解绑 */ public void removeConnection(){ tl.remove(); }}AOP告诉（事务管理器） ...

前情提要假如当初项目经理有一个需要：在我的项目现有所有类的办法前后打印日志。 你如何在不批改已有代码的前提下，实现这个需要？ 动态代理 具体做法如下： 1.为现有的每一个类都编写一个对应的代理类，并且让它实现和指标类雷同的接口（假如都有） 2.在创立代理对象时，通过结构器塞入一个指标对象，而后在代理对象的办法外部调用指标对象同名办法，并在调用前后打印日志。也就是说，代理对象 = 加强代码 + 指标对象（原对象），有了代理对象后，就不必原对象了 动态代理的缺点 程序员要手动为每一个指标类，编写对应的代理类。如果以后零碎曾经有成千盈百个类，工作量太大了。所以，当初咱们的致力方向是：如何少写或者不写代理类，却能实现代理性能？ 接口创建对象的可行性剖析温习对象的创立过程 首先，在很多初学者的印象中，类和对象的关系是这样的： 尽管晓得源代码通过javac命令编译后会在磁盘中失去字节码文件（.class文件），也晓得java命令会启动JVM将字节码文件加载进内存，但也仅仅止步于此了。至于从字节码文件加载进内存到堆中产生对象，期间具体产生了什么，他们并不分明。 所谓“万物皆对象”，字节码文件也难逃“被对象”的命运。它被加载进内存后，JVM为其创立了一个对象，当前所有该类的实例，皆以它为模板。这个对象叫Class对象，它是Class类的实例。 大家想想，Class类是用来形容所有类的，比方Person类，Student类...那我如何通过Class类创立Person类的Class对象呢？这样吗： Class clazz = new Class();如同不对吧，我说这是Student类的Class对象也行啊。有点晕了... 其实，程序员是无奈本人new一个Class对象的，它仅由JVM创立。 Class类的结构器是private的，杜绝了外界通过new创立Class对象的可能。当程序须要某个类时，JVM本人会调用这个结构器，并传入ClassLoader（类加载器），让它去加载字节码文件到内存，而后JVM为其创立对应的Class对象为了不便辨别，Class对象的表示法为：Class<String>，Class<Person>所以借此机会，咱们无妨换种形式对待类和对象： 也就是说，要失去一个类的实例，要害是先失去该类的Class对象！只不过new这个关键字切实太不便，为咱们暗藏了底层很多细节，我在刚开始学习Java时甚至没意识到Class对象的存在。 接口Class和类Class的区别 来剖析一下接口Class和类Class的区别。以Calculator接口的Class对象和CalculatorImpl实现类的Class对象为例： import java.lang.reflect.Constructor;import java.lang.reflect.Executable;import java.lang.reflect.Method;public class ProxyTest { public static void main(String[] args) { /*Calculator接口的Class对象 失去Class对象的三种形式：1.Class.forName(xxx) 2.xxx.class 3.xxx.getClass() 留神，这并不是咱们new了一个Class对象，而是让虚拟机加载并创立Class对象 */ Class<Calculator> calculatorClazz = Calculator.class; //Calculator接口的结构器信息 Constructor[] calculatorClazzConstructors = calculatorClazz.getConstructors(); //Calculator接口的办法信息 Method[] calculatorClazzMethods = calculatorClazz.getMethods(); //打印 System.out.println("------接口Class的结构器信息------"); printClassInfo(calculatorClazzConstructors); System.out.println("------接口Class的办法信息------"); printClassInfo(calculatorClazzMethods); //Calculator实现类的Class对象 Class<CalculatorImpl> calculatorImplClazz = CalculatorImpl.class; //Calculator实现类的结构器信息 Constructor<?>[] calculatorImplClazzConstructors = calculatorImplClazz.getConstructors(); //Calculator实现类的办法信息 Method[] calculatorImplClazzMethods = calculatorImplClazz.getMethods(); //打印 System.out.println("------实现类Class的结构器信息------"); printClassInfo(calculatorImplClazzConstructors); System.out.println("------实现类Class的办法信息------"); printClassInfo(calculatorImplClazzMethods); } public static void printClassInfo(Executable[] targets){ for (Executable target : targets) { // 结构器/办法名称 String name = target.getName(); StringBuilder sBuilder = new StringBuilder(name); // 拼接左括号 sBuilder.append('('); Class[] clazzParams = target.getParameterTypes(); // 拼接参数 for(Class clazzParam : clazzParams){ sBuilder.append(clazzParam.getName()).append(','); } //删除最初一个参数的逗号 if(clazzParams!=null && clazzParams.length != 0) { sBuilder.deleteCharAt(sBuilder.length()-1); } //拼接右括号 sBuilder.append(')'); //打印 结构器/办法 System.out.println(sBuilder.toString()); } }}运行后果： ...

一个小需要：给原有办法增加日志打印假如当初咱们有一个类Calculator，代表一个计算器，它能够进行加减乘除操作 public class Calculator { //加 public int add(int a, int b) { int result = a + b; return result; } //减 public int subtract(int a, int b) { int result = a - b; return result; } //乘法、除法...}现有一个需要：在每个办法执行前后打印日志。你有什么好的计划？ 间接批改 很多人最直观的想法是间接批改Calculator类： public class Calculator { //加 public int add(int a, int b) { System.out.println("add办法开始..."); int result = a + b; System.out.println("add办法完结..."); return result; } //减 public int subtract(int a, int b) { System.out.println("subtract办法开始..."); int result = a - b; System.out.println("subtract办法完结..."); return result; } //乘法、除法...}下面的计划是有问题的： ...

一 代理模式 定义：在拜访指标对象的时候，提供一种间接拜访的办法，通过代理对象去拜访指标对象，达到客户端的目标。 益处：爱护指标对象；在指标对象的行为根底上，代理对象能够减少本人的解决，使得同一个指标对象能够满足不同的客户端的目标。 代理模式的模型： 波及三个角色： RealSubject：指标对象，也是真正要做事件的人。 Proxy：代理对象，持有对指标对象的援用，裸露给客户端，通过操作指标对象来实现客户端的目标。并且，代理对象能够在操作指标对象的前后做一些自定义的行为，灵便扩大了指标对象。 Subject：指标对象和代理对象的形象，以便在任何应用指标对象的中央都能够应用代理对象。Subject能够是一个接口也能够是一个抽象类。 二 动态代理 以最简略的模式实现上述模型 public interface Subject { void doRequst();}public class RealSubject implements Subject { @Override public void doRequst() { System.out.println("it's the thing i really want to do"); }}public class Proxy implements Subject { private Subject subject; public Proxy(Subject subject){ this.subject = subject; } @Override public void doRequst() { System.out.println("before do the real thing"); subject.doRequst(); System.out.println("after do the real thing"); }}public class Client { public static void main(String[] args) { Proxy proxy = new Proxy(new RealSubject()); proxy.doRequst(); }}/**before do the real thingit's the thing i really want to doafter do the real thing**/这种实现形式即常说的动态代理，有几个方面的束缚： ...

一 代理模式 定义：在拜访指标对象的时候，提供一种间接拜访的办法，通过代理对象去拜访指标对象，达到客户端的目标。 益处：爱护指标对象；在指标对象的行为根底上，代理对象能够减少本人的解决，使得同一个指标对象能够满足不同的客户端的目标。 代理模式的模型： 波及三个角色： RealSubject：指标对象，也是真正要做事件的人。 Proxy：代理对象，持有对指标对象的援用，裸露给客户端，通过操作指标对象来实现客户端的目标。并且，代理对象能够在操作指标对象的前后做一些自定义的行为，灵便扩大了指标对象。 Subject：指标对象和代理对象的形象，以便在任何应用指标对象的中央都能够应用代理对象。Subject能够是一个接口也能够是一个抽象类。 二 动态代理 以最简略的模式实现上述模型 public interface Subject { void doRequst();}public class RealSubject implements Subject { @Override public void doRequst() { System.out.println("it's the thing i really want to do"); }}public class Proxy implements Subject { private Subject subject; public Proxy(Subject subject){ this.subject = subject; } @Override public void doRequst() { System.out.println("before do the real thing"); subject.doRequst(); System.out.println("after do the real thing"); }}public class Client { public static void main(String[] args) { Proxy proxy = new Proxy(new RealSubject()); proxy.doRequst(); }}/**before do the real thingit's the thing i really want to doafter do the real thing**/这种实现形式即常说的动态代理，有几个方面的束缚： ...

上一篇：SpringBoot 动态代理|反射|注解|AOP 优化代码(三)-注解 本篇我们将实现通过代理生成的对象注入到spring容器中。首先需要实现BeanDefinitionRegistryPostProcessor, ApplicationContextAware两个接口，作用分别为：ApplicationContextAware：可以获得ApplicationContext对象，然后获取Spring容器中的对象BeanDefinitionRegistryPostProcessor：可以将我们自定义的bean注入到spring容器 @Slf4j@Componentpublic class HandlerBeanDefinitionRegistry implements BeanDefinitionRegistryPostProcessor, ApplicationContextAware { private ApplicationContext applicationContext; @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException { /** * 获取AutoImpl注解的接口，这些接口就需要通过动态代理提供默认实现 */ Set<Class<?>> classes = getAutoImplClasses(); for (Class<?> clazz : classes) { /** * 获取继承自HandlerRouter的接口的泛型的类型typeName，传入到DynamicProxyBeanFactory * 以便传入到DynamicProxyBeanFactory扫描typeName的实现类，然后按照feign和url两种实现 * 方式分类 */ Type[] types = clazz.getGenericInterfaces(); ParameterizedType type = (ParameterizedType) types[0]; String typeName = type.getActualTypeArguments()[0].getTypeName(); /** * 通过FactoryBean注入到spring容器，HandlerInterfaceFactoryBean实现以下功能： * 1.调用动态代理DynamicProxyBeanFactory提供HandlerRouter子接口的默认实现 * 2.将第一步的默认实现，注入到spring容器 */ HandlerRouterAutoImpl handlerRouterAutoImpl = clazz.getAnnotation(HandlerRouterAutoImpl.class); BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(clazz); GenericBeanDefinition definition = (GenericBeanDefinition) builder.getRawBeanDefinition(); definition.getPropertyValues().add("interfaceClass", clazz); definition.getPropertyValues().add("typeName", typeName); definition.getPropertyValues().add("context", applicationContext); definition.setBeanClass(HandlerInterfaceFactoryBean.class); definition.setAutowireMode(GenericBeanDefinition.AUTOWIRE_BY_TYPE); beanDefinitionRegistry.registerBeanDefinition(handlerRouterAutoImpl.name(), definition); } } @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException { log.info("------------------------>postProcessBeanFactory"); } /** * 通过反射扫描出所有使用HandlerRouterAutoImpl的类 * @return */ private Set<Class<?>> getAutoImplClasses() { Reflections reflections = new Reflections( "io.ubt.iot.devicemanager.impl.handler.*", new TypeAnnotationsScanner(), new SubTypesScanner() ); return reflections.getTypesAnnotatedWith(HandlerRouterAutoImpl.class); } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.applicationContext = applicationContext; log.info("------------------->setApplicationContext"); } /** * 通过class获取所有该类型的bean * * @param clazz * @return */ private Map<String, T> getBeans(Class<T> clazz) { return applicationContext.getBeansOfType(clazz); } private String getYmlProperty(String propery) { return applicationContext.getEnvironment().getProperty(propery); }}HandlerInterfaceFactoryBean 通过动态代理创建默认实现类 ...

上一篇SpringBoot 动态代理|反射|注解|AOP 优化代码(二)-反射 我们实现了通过反射完善找到目标类，然后通过动态代理提供默认实现，本篇我们将使用自定义注解来继续优化。 创建注解1.创建枚举 ClientType,用来标明Handler的实现方式 public enum ClientType { FEIGN,URL}2.创建注解ApiClient,用来标明Handler的实现方式 @Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public @interface ApiClient { ClientType type();}3.创建HandlerRouterAutoImpl注解，来标记该HandlerRouter是否通过代理提供默认实现 @Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public @interface HandlerRouterAutoImpl { /** * 在spring容器中对应的名称 * @return */ String name();}4.DeviceHandlerRouter添加注解，以动态代理提供默认实现 @HandlerRouterAutoImpl(name = "deviceHandlerRouter")public interface DeviceHandlerRouter extends HandlerRouter<DeviceHandler> {}5.DeviceHandlerFeignImpl、DeviceHandlerUrlImpl 添加注解标明具体的实现方式 @ApiClient(type = ClientType.FEIGN)@Component@Slf4jpublic class DeviceHandlerFeignImpl implements DeviceHandler { @Autowired private DeviceFeignClient deviceFeignClient; @Override public void remoteAddBatch(RemoteAddDeviceParam remoteAddDeviceParam, Integer envValue) { RestResult restResult = deviceFeignClient.create(remoteAddDeviceParam); ... } @Override public void remoteDeleteBatch(Integer envValue, List<String> snsList) { RestResult restResult = deviceFeignClient.deleteBySnList(snsList); ... } }@ApiClient(type = ClientType.URL)@Component@Slf4jpublic class DeviceHandlerUrlImpl implements DeviceHandler { @Override public void remoteAddBatch(RemoteAddDeviceParam remoteAddDeviceParam, Integer envValue) { String url = getAddUrlByEnvValue(envValue); String response = OkHttpUtils.httpPostSyn(url, JSON.toJSONString(snsList), false); RestResult restResult = JSON.parseObject(response, RestResult.class); ... } @Override public void remoteDeleteBatch(Integer envValue, List<String> snsList) { String url = getDelUrlByEnvValue(envValue); String response = OkHttpUtils.httpPostSyn(url, JSON.toJSONString(snsList), false); RestResult restResult = JSON.parseObject(response, RestResult.class); ... }}6.通过注解扫描目标类 ...

一、背景在项目中需要调用外部接口，由于需要调用不同环境（生产、测试、开发）的相同接口（例如：向生、测试、开发环境的设备下发同一个APP）。 1.生产环境由SpringCloud注册中心，通过Feign调用，2.其它环境直接通过OKHttp直接通过Url调用。因此需要根据传入的环境调选择不同的调用方式。 优化前代码结构下面以添加和删除设备接口为例（一切从简,不代表真正业务代码）： public interface DeviceHandler { void remoteAddBatch(RemoteAddDeviceParam remoteAddDeviceParam, Integer envValue); void remoteDeleteBatch(Integer envValue, List<String> snsList);}Feign方式实现： @Component@Slf4jpublic class DeviceHandlerFeignImpl implements DeviceHandler { @Autowired private DeviceFeignClient deviceFeignClient; @Override public void remoteAddBatch(RemoteAddDeviceParam remoteAddDeviceParam, Integer envValue) { RestResult restResult = deviceFeignClient.create(remoteAddDeviceParam); ... } @Override public void remoteDeleteBatch(Integer envValue, List<String> snsList) { RestResult restResult = deviceFeignClient.deleteBySnList(snsList); ... } }Url方式实现 @Component@Slf4jpublic class DeviceHandlerUrlImpl implements DeviceHandler { @Override public void remoteAddBatch(RemoteAddDeviceParam remoteAddDeviceParam, Integer envValue) { String url = getAddUrlByEnvValue(envValue); String response = OkHttpUtils.httpPostSyn(url, JSON.toJSONString(snsList), false); RestResult restResult = JSON.parseObject(response, RestResult.class); ... } @Override public void remoteDeleteBatch(Integer envValue, List<String> snsList) { String url = getDelUrlByEnvValue(envValue); String response = OkHttpUtils.httpPostSyn(url, JSON.toJSONString(snsList), false); RestResult restResult = JSON.parseObject(response, RestResult.class); ... }}起到路由作用的DeviceHandlerRouter(其实类似代理)，选择具体调用哪种实现，对上传服务暴露的是DeviceHandlerRouter。 ...

原文链接："犯罪心理"解读Mybatis拦截器 Mybatis拦截器执行过程解析 文章写过之后，我觉得 “Mybatis 拦截器案件”背后一定还隐藏着某种设计动机，里面大量的使用了 Java 动态代理手段，它是怎样应用这个手段优雅的设计出整个拦截事件的？就像抓到罪犯要了解它犯罪动机是什么一样，我们需要解读 Mybatis拦截器的设计理念： 设计解读Java 动态代理我们都懂得，我们先用它设计一个基本拦截器首先定义目标对象接口： public interface Target { public void execute();}然后，定义实现类实现其接口： public class TargetImpl implements Target { public void execute() { System.out.println("Execute"); }}最后，使用 JDK 动态代理定义一个代理类，用于为目标类生成代理对象： public class TargetProxy implements InvocationHandler { private Object target; private TargetProxy(Object target) { this.target = target; } //代理对象生成目标对象 public static Object bind(Object target) { return Proxy.newProxyInstance(target.getClass() .getClassLoader(), target.getClass().getInterfaces(), new TargetProxy(target)); } // public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("Begin"); return method.invoke(target, args); }}这时，客户端调用方式如下： ...

个人理解：一个工厂生产冰箱，冰箱从工厂生产出来到消费者手中一般还有有一个代理商，提供一些服务，比如附赠一些小礼品，送货上门等等Spring中就使用了动态代理的思想，比如Spring的反向代理加依赖注入，就相当于送货上门Spring里的AOF面向切面编程就使用了动态代理达到事务控制、日志打印功能，就相当于附赠一些小礼品。

平时我们使用spring框架，不论是springmvcv还是springboot,springCloud，绝大多数情况我们都是在方法，或者直接在类上面加一个@Transactional，将事务交给spring替我们去管理，然后并没有具体分析一些情况，今天结合几个例子，结合源代码，使用伪代码解释一波。 1.情况一 service(){ //方法A methodA(){ insertA(); } //方法B @Transactional methodB(){ insertB(); throw new RunTimeException(“强制抛一个异常”); } public void static main(String[] args){ methodA(); methodB(); } }情况一就是这样，main方法里面顺序调用AB两个方法，A方法不加事务注解，B方法加了事务注解。如果不了解@Transactional 事务的传播性，可能会回答：A成功插入，B插入失败,但是实际情况却是A,B均插入成功了。到底是什么原因呢？这里先简单介绍一下事务的6个传播属性：PROPAGATION_REQUIRED ： 支持当前事务，如果当前没有事务，就新建一个事务，这也是最常见的PROPAGATION_SUPPORTS ： 支持当前事务，如果当前没有事务，就以非事务的方式执行PROPAGATION_MANDATORY： 支持当前事务，如果当前没有事务，就抛异常PROPAGATION_REQUIRES_NEW：新建事务，如果当前事务存在，就把当前事务挂起PROPAGATION_NOT_SUPPORTED：以非事务的方式执行，如果存在当前事务，就把当前事务挂起PROPAGATION_NEVER： 以非事务的方式执行，如果当前存在事务，就抛异常PROPAGATION_NESTED：如果存在当前事务，则在嵌套事务内执行，如果当前没有事务，则新建一个事务前六个策略类似于EJB CMT，第七个（PROPAGATION_NESTED）是Spring所提供的一个特殊变量。研究源码，调试程序可以看到：A没有事务管理，则线程内的connection 有个autoCommit = trueB得到事务的时候，由于事务的传播性依然生效, 得到的还是A方法的commit,其autoCommit = true,故而逐条sql进行提交，即A,B都会插入下面我们来分析情况二：serviceA(){ methodA(){ insertA(); }} serviceB(){ @Transactional methodB(){ insertB(); throw new RuntimeExcption(“强制抛出的异常”); }}serviceC(){ @Autowired private ServiceA serviceA; @Autowired private ServiceB serviceB; public void staic main(String[] args){ serviceA.methodA(); serviceB.methodB(); }}情况二的主要代码和情况一一样，都是要调用methodA和methodB,但是结果却不同，情况二的正确结果是指挥插入A，而B会回滚，这是为什么呢？同样是在B方法上面加了事务注解….其实大家都知道，spring的事务是交由cglib动态代理的，而动态代理对象产生的时机就非常重要了。再回到本例子：A：在同一个service内部，事务之间嵌套调用，普通方法和事务方法之间的嵌套调用，都不会开启新的事务(因为shpring使用的是动态代理的方式来控制的事务,而动态代理最终都是要调用原始对象的，而原始对象在调用方法时，已存在代理对象，是不会再触发代理了！)B：两个方法在不同的service里(即不同的对象，即代理对象也不是同一个),在ServiceC中，使用注入的方式将serviceA和serviceB注入,这样即使A没有使用事务，B也有自己的代理，会根据PROPAGATION_REQUIRED 而生成新的事务.