Technology sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

1. agentis introductio

Procuratorium refertur ad modum quo obiectum A potest habere eandem habitudinem ac B tenendo aliud B. Ut protocollum ad exteriora patefaciat, B saepe interfaciem inducit, et A etiam interfaciem efficiet. Sed B est exsecutio ordinis "realis", dum A magis est "virtualis". Etsi A est "pseudo exercitus", potest augere B et alia facere ante et post modum B vocationis. Ver AOP utitur procuratoribus dynamicis ad complendum dynamicum "texendi" codicis.

Beneficia procuratoris utendi hoc excedunt. Si consilium innititur interfacii ab alio incepto, sed interfacies alterius consilii instabilis est et protocollum saepe mutatur, procuratorem uti potes tantum opus est procuratorem mutare, non singillatim mutare. Hoc sensu, hoc facere possumus omnibus interfaces quae extra mundum accommodant ne codicem extra codicem nostrum invaderent. Multae aliae possunt esse applicationes ad procurandum.

In exemplo superiore, genus A indurabitur ad habendum B, quod est static procuratoris B. Si obiectum procuratoris incertum est, est procurator dynamicus. In praesenti sunt duae exsecutiones communes procuratoris dynamici, jdk procuratorem dynamicum et cglib procuratorem dynamicum.

2. Static procuratorem

Procurator static consilium est ratio exemplaris et ratio ineundo ratio. In procuratore static, procurator classis definita est antequam programma currat, et relatio inter procuratorem ordinis et pro- curatorem classis tempore compilatae determinatur. Hoc significat quod tam procurator classis quam procurator ordinis eundem interfaciem vel heredes eiusdem ordinis parentem , addere potest aliquas operationes tuas ante et post vocationem, ut loging, licentia recognitionis, transactionis processus, etc.

Procurator statorum tria habet membra: interfaciem abstractam, procuratorem classis et procuratorem ordinis.

I) Define abstracti interface

public interface TargetInteface {
    void method1();
    void method2();
    int method3(Integer i);
}

II) Definire procuratorem ordinis

public class TargetProxy implements TargetInteface {
 
    private Target target =new Target();
    @Override
    public void method1() {
        System.out.println("执行方法前...");
        target.method1();
        System.out.println("执行方法后...");
    }
 
    @Override
    public void method2() {
        System.out.println("执行方法前...");
        target.method2();
        System.out.println("执行方法后...");
    }
 
    @Override
    public int method3(Integer i) {
        System.out.println("执行方法前...");
        int method3 = target.method3(i);
        System.out.println("执行方法后...");
        return method3;
    }
}

III) Definire procuratorem ordinis

public class Target implements TargetInteface {
    @Override
    public void method1() {
        System.out.println(" Target method1 running ...");
    }
 
    @Override
    public void method2() {
        System.out.println("Target method2 running ...");
    }
 
    @Override
    public int method3(Integer i) {
        System.out.println("Target  method3 running ...");
        return i;
    }
}

IV) Definire clientem ac videre supplicium results

public class TargetUser {
 
    public static void main(String[] args) {
        TargetInteface target = new TargetProxy();
        target.method1();
        System.out.println("-----------------------------");
        target.method2();
        System.out.println("-----------------------------");
        System.out.println(target.method3(3));
    }
}

Exitus output:

Priusquam modum exequendi...
Scopum method1 currit...
Post modum exequendi...
-----------------------------
Priusquam modum exequendi...
Target method2 cursus...
Post modum exequendi...
-----------------------------
Priusquam modum exequendi...
Target method3 currens...
Post modum exequendi...
3

Non difficile est videre ex exsecutione agentium staticorum commoda agentium static esse ad exsequendam simplicem et ad intellegendum facilem. Sed defectus eius etiam manifestae sunt, id est, quotiescumque opus est procuratorem ad novam classi functionem addere, debes manually novum procuratorem classium creare, quod ad acrem numerum classium augendum et ad sustentationem gratuita incrementa deducet. . Eodem tempore gradus coniunctionis inter procuratorem ordinis et procuratorem nimis est altus. qui meliorem codicem conservavit. Alia quaestio est, quod, cum procurator obiecti ad exsequendum classes multiplices scopos interfacies applicat, oportet esse diversas methodos in multiplicibus generibus exsequendi. Quia procurator obiectum debet efficere idem interface ac scopum obiectum (actu inclusionis relationis), necesse est Numerosae methodi scribendae sunt, facile ad tumidum ac difficile ad codicem retinendum.

3. Dynamic procuratorem

In media idea procuratoris dynamici est indirecte accedere ad obiectum originale per procuratorem obiectum sine modificatione obiecti primi codicis, et operationes additionales ante et post accessum praestare.

Principium exsecutionis procuratoris dynamici maxime fundatur in mechanismo Javae reflexionis. Cum procuratoribus dynamicis utendo, definire debes interfacium vel interfaces quae mores proximi ordinis definiunt (obiectum proxumum).Tum scribere debes exsecutionemInvocationHandler Classis instrumenti, hoc genus logicam continet quae ante et post methodum exsecuta est vocat in obiecto procuratoris.quando vocantemProxy.newProxyInstance()methodus, transi in genere oneratus interfaciei, interface instructus etInvocationHandlerObjectum, Java dynamice generabit procuratorem classis quae certa interface in runtime conficit et modum delegatum vocat adInvocationHandler obiicit ad processum.Cum modus procuratoris obiecti vocetur, actu vocatInvocationHandlerInterfaceinvoke()Methodus, in qua potes aliquam logicam praeprocedere, quae in methodo nominis, parametris et aliis informationibus nititur, ac deinde respondentem rationem obiecti procuratoris per reflexionem vocamus.

Deinde duos procuratores dynamicos introducimus: JDK proxy et CGLib

1）JDK Proxy

Internum mechanismum JDK Proxy

JDK Proxy utitur Iava meditatione mechanismum ad classes dynamice generandas procuratorem. Speciatim,Proxygenus erit utarProxyGenerator genus (quamvis hoc genus API publica non est, clavis est ad dynamicam procurationem intra JDK exsequendam) generandi bytecode procuratoris classis eamque in JVM onerant.Procuratorem generatum genus inde possidebitjava.lang.reflect.Proxy genus et effectum deducendi certa interface.In methodo procuratoris classis vocabiturInvocationHandlerof*invokeMethodus accedat modum vocationis ad processum processus.

Praeterea, ad emendam perficiendam, JDK Proxy etiam caching mechanismum praebet ad obiectum classis procuratoris generati. Hoc modo, cum opus procuratorem eiusdem generis creare debes, obiectum procuratoris classis directe obtinere potes e cella sine regeneratione.Caching est viaWeakCacheClassis impleta, debilibus indiciis ad objecta cachecta utitur ut cache vasa quae iam non sunt, automatice purgari possunt, cum collectionem JVM purgamentum facit.

exsequendam gradus JDK proxy

• Define interfaces proxied classes: Primo diffinimus unum vel plura valucula, quae perficiantur per procuratorem ordinis.

public interface TargetInteface {
    void method1();
    void method2();
    int method3(Integer i);
}

public class Target implements TargetInteface {
    @Override
    public void method1() {
        System.out.println("method1 running ...");
    }
 
    @Override
    public void method2() {
        System.out.println("method2 running ...");
    }
 
    @Override
    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

• CreateInvocationHandler: perficiendumInvocationHandlerinterface et RESCRIBOinvoke modum.existinvokeIn methodo, logicam consuetudinem addere potes, ut colligationem, licentiam tenendi, etc., ac methodum per reflexionem vocas primae classis.
• Generare procuratorem objectum: translatioProxy.newProxyInstancemethodus transiens in oneratus classium, interface ordinata etInvocationHandler Exempli gratia ad objecta dynamice generare procuratorem. Haec methodus redit instantiam procuratorem in genere qui certum instrumenti instrumenti conficit.

public class TargetProxy {
    public static  <T> Object getTarget(T t) {
        //新构建了一个 新的 代理类的对象
        return Proxy.newProxyInstance(t.getClass().getClassLoader(), t.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // proxy就是目标对象t，method就是调用目标对象中方法，args就是调用目标对象中方法的参数。
                        //比如说：代理对象.method1(),这时proxy就是目标类，method1就是method,args就是method1方法参数。
                        System.out.println("执行方法前...");
                        Object invoke = method.invoke(t, args);
                        System.out.println("执行方法后...");
                        return invoke;
            }
        });
    }
}

• Utere procuratorem objectorum: Cum modus per procuratorem dicitur, actu vocaturInvocationHandlerof*invokeMethodus, in qua logica consuetudo conficitur et tum modus primi generis appellatur.

public class TargetUser {
 
    public static void main(String[] args) {
        TargetInteface target = (TargetInteface) TargetProxy.getTarget(new Target());
        target.method1();
        System.out.println("-----------------------------");
        target.method2();
        System.out.println("-----------------------------");
        System.out.println(target.method3(3));
    }
}

Exitus output:
Priusquam modum exequendi...
method1 currentem ...
Post modum exequendi...
-----------------------------
Priusquam modum exequendi...
method2 currentem ...
Post modum exequendi...
-----------------------------
Priusquam modum exequendi...
method3 currentem ...
Post modum exequendi...
3

Features of JDK Proxy

1. Interface procuratorem: JDK Proxy non potest nisi procuratorem classes, quae interfaciunt deducendi, et genera ordinaria quae interfaciendi non efficiunt, procuratorem facere non potest.
2. Dynamically generatae: Procurator classium in runtime dynamice generatur, et tincidunt non opus est ut signum manually scribat pro procuratorio classium.
3. Princeps flexibilitate: Additamentum functionis vel logicae ad classem originalem addi potest sine modificatione primigenii codicis.
4. euismod considerations: Ob reflexionem et generationem dynamicam, exsecutio JDK Proxy leviter inferior potest esse quam procuratorum statorum vel vocatorum ad modos primi generis directi.

2）CGLib

Core principium CGLib procuratorem dynamicum

1. Bytecode res : CGLib ASM (parvo et celeriter bytecode machinationis compage) sub cucullo ad dynamice generandum novas Javae classes (plerumque subclasses classium scopo). Hae classes nuper generatae ex clypeo classis possident et logicam procuratorem inserunt cum methodus appellatur.
2. Modus interceptionis : nucleus functionis CGLib est interceptio methodi gradus efficiendi.Developers implementMethodInterceptorinterface ad definiendum modum interceptoris, qui mos logicae ante et post modum vocationis objecti procuratoris exequetur, ut praeprocessing, postprocessing, exceptio tractatio, etc.
3. FastClass mechanism : Ut ad corrigendum perficiendum, CGLib FastClass mechanism adoptat. FastClass modos clypei indicat et methodum scopum directe per indicem vocantem accesserit. Haec methodus multo celerior est quam repercussio Java.

exsequendam gradus dynamicos CGLib procuratorem

• Introducendis CGLib clientelas: CGLib's Maven vel Gradle dependentiam in project.

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

• Define scopum genus: Definire scopo classis quae proxied esse debet.

public class Target {
    public void method1() {
        System.out.println("method1 running ...");
}
 
    public void method2() {
        System.out.println("method2 running ...");
    }
 
    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

• MethodInterceptor deducendi interface: Create an implementationMethodInterceptorinterface genus et primi ante Christumintercept modum. Logicam scribe in hac methodo procuratorem.
• Create procuratorem objectum: Utere uno provisum a CGLibEnhancer genus creare procuratorem rerum.Vos postulo ut ad genus proxied (viasetSuperclassmodum) et callbacks (via *setCallbackMethodus inserendi methodos interceptor classis).

public class TargetProxy {
    public static <T> Object getProxy(T t) {
        Enhancer en = new Enhancer(); //帮我们生成代理对象
        en.setSuperclass(t.getClass());//设置要代理的目标类
        en.setCallback(new MethodInterceptor() {//代理要做什么
            @Override
            public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                System.out.println("执行方法前。。。");
                //调用原有方法  
                Object invoke = methodProxy.invokeSuper(object, args);
                // Object invoke = method.invoke(t, args);// 作用等同与上面。
                System.out.println("执行方法后。。。");
                return invoke;
            }
        });
        return en.create();
    }
}

• Utere procuratorem objectorum: Urguet ratio scopo classis per objectum procuratorem appellaturinterceptProcurator logicae in methodis.

public class TargetUser {
 
    public static void main(String[] args) {
        Target target = (Target) TargetProxy.getProxy(new Target());
        System.out.println(target.getClass().getName());
        target.method1();
    }
 
}

Exitus output:

com.heaboy.aopdemo.cglibproxy.Target $$EnhancerByCGLIB$$ f9f41fb8
antequam modus faciendi. . .
method1 currentem ...
Modum deinde exequendi. . .

Lorem missionibus CGLib dynamicam procuratorem

1. Opus procuratori classes quae interfaces non efficiuntCum scopo classis nullum interfaciem efficiat, CGLib per procuratorem adhiberi potest.
2. Princeps perficientur necessaria: In missionibus cum maximis requisitis perficiendis, si JDK procuratorem dynamicum necessitatibus occurrere non potest, considerare potes utens CGLib.
3. AOP compage implementation: In compagibus programmandi aspectum ordinatum, sicut Ver AOP, cum genus quod interfacies non efficiendum indiget ut proxied, CGLib adhiberi solet ut exsecutio subiecta.

Commoda et incommoda CGLib procuratorem dynamicum

Commodum ;

1. Princeps flexibilitate: procuratorem classes possunt, quae interfacies non efficiunt, ambitum applicationis procuratoris dilatare.
2. Melius perficientur: Per mechanismum FastClass, vocatio efficientia altior est quam reflexio mechanismi dynamici procuratoris JDK.
3. Validus: subsidia dynamice additis functionality vel logicis additis ad classes in runtime scopo sine modificatione primigenii codicis.

Defectus;

1. Bytecode operatio caput: Dynamice bytecode generans et onerans in JVM quadam perficiendi supra caput feret.
2. Posse procuratorem ultima genera et modos: Cum instrumentis CGLib procuratorem classium scopo possidendo, procuratorem classes ac modos finales mutari non potest.
3. More complexu utendi: comparatus cum JDK procuratorem dynamicum, CGLib magis complexus est uti et indiget ad additional clientelas introducendas et tractandum cum exitibus generationis bytecode.

3）JDK proxy VS CGLib

Proxy object type:JDK Proxy potest solum procuratorem classes, quae interfaciunt efficiendum;

perficiendi; CGLib genera procuratoris classes in runtime generat et generaliter paulo melius quam JDK proxy praestare censetur. Sed in plerisque missionibus, haec differentia effectus non est significativa.

argumenta adhibenda; Si obiectum scopus iam instrumenti instrumenti ad effectum adducitur, proxy usus JDK est optio simplex et directa. Si opus est procuratorem ordinis quod interfaciem non efficiat, CGLib uti debetis.

inniti;JDK Proxy non requirit additas dependentias, quia pars bibliothecae nuclei Javae est;

JDK Proxy functio est quae cum lingua Java venit et non indiget ut perficiatur onerariis classibus tertiae partis;

Java firmamentum pro JDK proxy praebet, ac perget ad upgrade ac renovationem JDK Proxy. Exempli gratia, proxy perficiendum in Java 8 versionis versionibus prioribus valde emendatis comparata est;

JDK Proxy impletur per interceptores et reflexiones;

JDK Proxy non potest nisi procuratorem classium qui interfacies hereditabunt;

JDK Proxy est relative simplex ad efficiendum et vocandum;

CGLib instrumentum est a tertia factione instructum, quae in ASM fundatur, et relative altum effectum habet;

CGLib non indiget ut per interfaciem impleatur, genus genus appellando.

4. Procurator Static VS dynamicus procurator

differentia

Procuratorem Static: Procuratores statorum in compilatione determinantur. Procurator classis scribenda est pro quolibet genere proximorum.

Procurator classium procuratoris statice in tempore compilare existit, quare procuratorem tantum genera specificarum potest cum progressio currit, nec potest dynamice discernere utrasque classes ineundo.

Procurator stabilis modum vocationis obiecti originalis involvit et logicam ante et post vocationem additam addere potest, sed procurator classis in antecessum scribenda est, quae quantitatem codicis augebit.

Procurator Static explicite designat procuratorem obiectum in codice et relative intuitive utendi, sed addit novum procuratorem classes recompensationem requirit.

Procurator dynamicus: Procurator dynamicus gignit procuratorem rerum in runtime sine litteris in antecessum procuratorem. Utere Java meditatione mechanismum ad genera dynamice generandi procuratorem et obiecta procuratoria.

Procuratores dynamici in interfaces nituntur et perficiuntur per java.lang.reflect. Proxy classis et java.lang.reflect. InvocationHandler interface.

Procurator dynamicus potest procuratorem genera plurium interfacientium et dynamice diiudicare utrasque classes ad procuratorem perducant. In runtime procuratores generari possunt ad diversa obiecta necessaria, maiorem flexibilitatem praebentes.

Procurator dynamicus non indiget scribere certum procuratorem classis pro cuiusque procuratoris genere, quod est flexibilius et codicem servat.

Dynamici agentes consuetudinem logicam addere possunt ante et post methodum vocat procuratorem in obiecto, ut colligationem, administrationem transactionis, etc. Incommodum procuratoris dynamici est quod comparatur cum procuratorio static, procuratorem generans obiecto tempore currentis, certum effectum supra caput requirit.

Lorem scaena

Procuratores static sunt idonei ad sequentes missiones;

Cum numerus obiecti scoporum (proxy objectorum) limitatur et determinatus est, procurator static perfici potest per litteras procuratoris classes manually. Procuratores static procuratores generant in tempore ordinandi, quo melius effectus habent in runtime.

Static procuratores obiecti scopum encapsulant et munera additamenta addunt sine modificatione codicis originalis. Hoc efficit ut procuratores staticos saepe adhibeant ad exitus incidendas curas ut colligationem et administrationem transactionis.

Procurator dynamicus aptus est pro missionibus sequentibus;

Cum numerus obiecti scopo incertus est vel praefixus determinari non potest, procuratores dynamici commodius generare procuratores possunt. Generat procuratorem classes et res in curriculo procuratorem, vitans taedium opus manualis scribentis plures procuratores classes.

Procuratores dynamici praebent flexibilitatem addendi, auferendi, vel mutandi mores procuratoris ad obiectis in runtime oppugnandis. Hoc efficit procuratores dynamicos saepe in applicatione missionum ut AOP (programma progressionis aspectum) et RPC (vocatio remota).

Animadvertendum est quod, quia procuratores dynamici generant et procuratores per reflexionem mechanismum in runtime obiectis creant, effectum suum leviter inferiorem esse possunt quam procuratorum statorum. Praeterea procuratores dynamici solum possunt obiecti scopo procuratores qui interfaciem efficiunt, cum procuratores statice hanc restrictionem non habent.

Ad summam, procuratores statice idonei sunt missionibus ubi numerus obiecti scoporum est limitatus et certus, et encapsulationes et functiones additional requirunt; et procurator morum mollius addenda, deleta vel mutanda. Aptam procurationem elige methodum certis necessitatibus et circumstantiis fundatam.

5. Proxy exsecutionem in SpringAOP

I) Introductio ad SpringAOP

Loqui intellectus AOP

Ver AOP magni momenti modulus est in opere vernali, ad aspectum ordinatum programmatis efficiendi.

Facie ad faciem programming , hoc est exemplar programmandi quod programmatores permittit modulari per consuetudinem transversis punctis et encapsulare mores quae multiplices classes in modulorum reusable afficiunt. Exempli gratia: Pro exemplo, stipes output, si AOP non uteris, necesse est ut stipes in omnibus generibus ac modis enunciationes ponas. Tamen, cum AOP, encapsulare potes enunciationes log output in moduli reusable et pone eas in a . modo declarativo.

In notione programmationis aspectus ordinantur, functiones in duas species dividuntur

• Vendans primus: Login, adnotatione, additio, deletio, immutatio et investigatio omnes nuclei vocantur

• Munus periphericum: Acta et administratione transactionis sunt officia secundaria peripheralia.

In programmatibus aspectum ordinatis, nuclei negotiatorum functiones et functiones peripherales independenter explicantur, et duae non coniunguntur. Tunc aspectus functiones et nucleus functionum negotiatorum sunt "textae" simul, quae AOP appellatur.

AOP convertere ea quae ad negotium non referuntur;Sed encapsulatum est ad logicam seu officia (ut negotium processus, procuratio loga, permissio dominii, etc.) vulgo a modulorum negotiorum nomine nuncupantur., Securus adRedigendum duplicata ratio in codice，Reduce coitu inter modules,etConducere ad futuram scalability et maintainability。

Sunt notiones sequentes in AOP:

• AspectJ: Aspectus conceptus iustus est.

• Adiungere punctum : Connexio punctum refertur ad punctum in programmatis executione, ut modus invocationis, exceptio tractatio, etc. In Veris AOP, solum puncta methodus gradus iungendi sustentantur.

• Admonitio : Notificatio , id est , logicam in modum crucis incisam definimus , tria habet genera : " circa " , " ante " et " post " . Multis compagibus exsequendi AOP, Consilium uti interceptorem plerumque agit, ac etiam multos interceptores continere potest ut nexum circa punctum iungendum discurrendum sit.

• Pointcut: Pointcut, puncta iungere solebant.

• Introductio : Introductio, permittens rationem declarandi consilium obiectis instrumentis adiectis efficiendi quod non actu efficiendum. Exempli causa, ineundo res adhiberi potest in duas classes clypei procuratoris.

• textrinum : textrinum, nunc quod habemus nexum puncta, puncta incisa, notificationes et aspectus, quomodo ad propositum applicandum? Iustum est, textura est. Praeeunte punctorum, logica notificatio methodo scopo inseritur, ut nostra notificatio logica perfici possit cum modus appellatur.

• AOP procuratorem : AOP procuratorem refert ad obiectum quod protocollum efficit aspectum in compage AOP exsecutionis. Duo genera procuratorum in Ver AOP sunt, scilicet procuratorem dynamicum JDK et procuratorem dynamicum CGLIB.

• Scopum object: Scopum obiectum est obiectum proxied.

Ver AOP in JDK dynamicum procuratorem et promotionem Cglib fundatur. Utriusque modi procuratoris methodi sunt runtime methodi, ergo processui temporis compilationem non habent, sic fons per Javam codicem perficitur.

Quod problema non AOP solve?

Communes mores aliquos inter plures classes vel obiecta dispersa (ut loging, administratio, administratio, licentia moderatio, modus interfaciendi modus, potestas interfaciendi, etc.), hi mores appellari solent. cross-sectione de . Si hos mores identidem in omni genere vel obiecto efficiamus, erit superuacua, multiplex et difficilis ad codicem conservandum.

AOP transmutare curas incidendi (ut logging, administrationem transactionis, permissionem potestatem, interface current limitationem, interface potestatem, etc.) e Core negotium logicum (core curas, core curas) Separate ab umbilico ad curarum separationem.

AOP application missionibus

• Logging: Mos logging annotationes et utere AOP ut colligationem cum una linea codicis perficias.

• Facis statistica: Utere AOP computare tempus exsecutionis methodi ante et post scopum exsecutionem methodi ad optimam ac analysim faciliorem reddendam.

• Administratio transactionis:@Transactional Annotationes permittunt ver ad administrationem transactionis nobis perficiendam, sicut operationes exceptiones revolutiones, repetitae administrationis logicae administrationem eliminant.@TransactionalAnnotationes in AOP implenda sunt.

• Permissionis imperium: AOP utere ad determinare utrum usor habeat debitas permissiones antequam scopum modum exequatur.For example, SpringSecurity utitur@PreAuthorize Licentiam dare potes customize verificationem in linea codicis explicantes.

• Interfaciei currentis limitatio: AOP utere ut petitionem per certas algorithms et implementationes current limitando limitando ante modum scopo efficiatur.

• Cache administratione: Utere AOP legere et renovare latibulum ante et post modum scopo afficitur.

Quomodo AOP impletur?

Communia exsecutionis methodi AOP includunt procuratorem dynamicum, operationem bytecode, etc.

Vere AOP in dynamico procuratore fundatur JDK ProxyAd rem procuratorem creare. Obiectis quae interfaciem non efficiunt, JDK proxy uti non potes Cglib Generare genus rei proxied ut procuratorem

II) Implement SpringAOP secundum JDK proxy dynamic procuratorem

Configure SpringAOP

existspring-aop.xmlConfigurare fabam et aspectus in configuration file

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 
    <bean id="target" class="com.xxhh.aopdemo.aop.Target"/>
 
    <bean id="targetAdvice" class="com.xxhh.aopdemo.aop.TargetAdvice"/>
 
    <bean id="targetProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target" ref="target"/> <!--被代理的类-->
        <property name="interceptorNames" value="targetAdvice"/>  <!--如果用多种增强方式,value的值使用逗号(,)分割-->
        <property name="proxyTargetClass" value="false"/> <!--如果设置为true，则创建基于类的代理（使用CGLIB）；如果设置为false，则创建基于接口的代理（使用JDK动态代理）。-->
        <property name="interfaces" value="com.xxhh.aopdemo.aop.TargetInteface"/>  <!--target实现的接口-->
    </bean>
</beans>

Define abstractum interface

public interface TargetInteface {
    void method1();
    void method2();
    int method3(Integer i);
}

Definire procuratorem ordinis

public class Target implements TargetInteface{
 
    /*
    * 需要增强的方法，连接点JoinPoint
    **/
    @Override
    public void method1() {
        System.out.println("method1 running ...");
    }
 
    @Override
    public void method2() {
        System.out.println("method2 running ...");
    }
 
    @Override
    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

Definire procuratorem ordinis (excretionis modum)

public class TargetAdvice implements MethodInterceptor, MethodBeforeAdvice, AfterReturningAdvice {
 
    /*
    * 通知/增强
    **/
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("前置环绕通知");
        Object proceed = methodInvocation.proceed();
        System.out.println("后置环绕通知");
        return proceed;
    }
 
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("后置返回通知");
    }
 
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("前置通知");
    }
}

Test

public class AopTest {
    public static void main(String[] args) {
        ApplicationContext appCtx = new ClassPathXmlApplicationContext("spring-aop.xml");
        TargetInteface targetProxy = (TargetInteface) appCtx.getBean("targetProxy");
        targetProxy.method1();
    }
}

Eventum output:

Circumdate ante notitia
Pre-notificazione
method1 currentem ...
post reditus notitia
Circumdate notitia

III) Implement SpringAOP secundum CGLib procuratorem dynamic

Configure SpringAOP

existspring-confaop.xmlConfigurare fabam et aspectus in configuration file

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
 
    <!--先开启cglib代理,开启 exposeProxy = true,暴露代理对象-->
    <aop:aspectj-autoproxy proxy-target-class="true" expose-proxy="true"/>
    <!--扫包-->
    <context:component-scan base-package="com.xxhh.aopdemo.annotationaop"/>
 
</beans>

Definire procuratorem ordinis

/*
* 目标类
**/
public class Target {
 
    public void method1() {
        System.out.println("method1 running ...");
    }
 
    public void method2() {
        System.out.println("method2 running ...");
    }
 
    /*
    * 连接点JoinPoint
    **/
    public int method3(Integer i) {
        System.out.println("method3 running ...");
//        int i1 = 1 / i;
        return i;
    }
}

Definire procuratorem ordinis (aspectu classis)

import org.aspectj.lang.ProceedingJoinPoint;
/*
* 切面类
**/
public class TargetAspect {
 
    /*
    * 前置通知
    **/
    public void before() {
        System.out.println("conf前置通知");
    }
 
    public void after() {
        System.out.println("conf后置通知");
    }
 
    public void afterReturning() {
        System.out.println("conf后置返回通知");
    }
 
    public void afterThrowing(Exception ex) throws Exception {
//        System.out.println("conf异常通知");
//        System.out.println(ex.getMessage());
    }
 
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Object proceed = null;
        if (!"".equals("admin")) {
            System.out.println("conf环绕前置");
            proceed = pjp.proceed(pjp.getArgs());
            System.out.println("conf环绕后置");
        }
        return proceed;
    }
}

Test

public class AopTest {
    public static void main(String[] args) {
        ApplicationContext appCtx = new ClassPathXmlApplicationContext("spring-confaop.xml");
        Target targetProxy = (Target) appCtx.getBean("target");
        System.out.println(targetProxy.method3(0));
    }
}

Eventum output:

conf prae notitia
conf circumdare praepositione
method3 currentem ...
conf post-reditus notitia
conf circumdare post
conf post notitia
0 

4) Implement SpringAOP secundum annotationem in procuratorem dynamicam

Configure SpringAOP

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
 
    <!--先开启cglib代理,开启 exposeProxy = true,暴露代理对象-->
    <aop:aspectj-autoproxy proxy-target-class="true" expose-proxy="true"/>
    <!--扫包-->
    <context:component-scan base-package="com.xxhh.aopdemo.annotationaop"/>
 
</beans>

Define annotationes

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TestAnnotation{
}

Definire aspect classes

/*
* 切面类
**/
@Aspect
@Component
public class AnnotationAspect {
 
    // 定义一个切点：所有被RequestMapping注解修饰的方法会织入advice
    @Pointcut("@annotation(TestAnnotation)")
    private void advicePointcut() {}
 
    /*
    * 前置通知
    **/
    @Before("advicePointcut()")
    public void before() {
        System.out.println("annotation前置通知");
    }
 
    @After("advicePointcut()")
    public void after() {
        System.out.println("annotation后置通知");
    }
 
    @AfterReturning(pointcut = "advicePointcut()")
    public void afterReturning() {
        System.out.println("annotation后置返回通知");
    }
 
    @AfterThrowing(pointcut = "advicePointcut()", throwing = "ex")
    public void afterThrowing(Exception ex) throws Exception {
        System.out.println("annotation异常通知");
        System.out.println(ex.getMessage());
    }
 
    @Around("advicePointcut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Object proceed = null;
        if (!"".equals("admin")) {
            System.out.println("annotation环绕前置");
            proceed = pjp.proceed(pjp.getArgs());
            System.out.println("annotation环绕后置");
        }
        return proceed;
    }
}

Controller addit annotationes

@Controller
public class TestController {
 
    @RequestMapping("/test.do")
    @ResponseBody
    public String testController() {
        TestController o = (TestController) AopContext.currentProxy();
        o.test();
//        System.out.println("tewt");
        return "ok";
    }
 
    @TestAnnotation
    public void test() {
        System.out.println("test running");
    }
 
}

Test