spring原始碼AOP解析

阿新 • • 發佈：2018-11-16

1、代理技術（靜態代理、JDK動態代理、CGLib代理）

靜態代理：
|-- Hello 
|-- void say(String name);
|-- HelloImpl implements Hello {
voiv say(String name){
    sysout("Hello!"+name);
}
}
|-- HelloProxy implents Hello {
    Hello hello; 
    HelloProxy(){
        hello = new HelloImpl();
    }
    voiv say(String name){
        before();
        sysout( 
"Hello!"+name);
        end();
    }
    void before(){
        sysout("Before");
    }
    void after(){
        sysout("After");
    }
    
    main(String[] args){
        Hello hello = new HelloProxy();
        hello.say("Jack");
    }
}
JDK動態代理：
|-- DynamicProxy implements InvocationHandler {
    Object target; 
    DynamicProxy (Object target){
         
this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args){
        before();
        object result = method.invoke(target, args);
        after();
        return result;
    }
    ...
    
    main(String[] args){
        // 嘗試1
        Hello hello = new 
 HelloImpl();
        DynamicProxy dynamicProxy = new DynamicProxy(hello);
        Hello hello = (Hello)Proxy.newProxyInstance(hello.getClass().getClassLoader(), hello.getClass.getInterfaces(), dynamicProxy);
        hello.say("Jack");
        
        // 嘗試2
        DynamicProxy dynamicProxy = new DynamicProxy(new HelloImpl());
        Hello hello = dynamicProxy.getProxy();
        hello.say("Jack");
    }
    
    public <T> T getProxy(){
        return (T)Proxy.newProxyInstance(
            target.getClass().getClassLoader(), 
            target.getClass.getInterfaces(), 
            this
        );
    }
}

CGLib動態代理：
|-- CGLibProxy implements MethodInterceptor {
    private static CGLibProxy instance = new CGLibProxy();
    
    private CGLibProxy() {}
    
    public CGLibProxy getInstance(){
        return instance;
    }

    public <T> T getProxy(Class<T> cls){
        return (T) Enhancer.create(cls, this);
    }
    public Object inercept(Object obj, Method method, Object[] args, MethodProxy proxy){
        before();
        Object result = proxy.invokeSuper(obj, args);
        after();
        return result;
    }
    ...    
    
    main(String[] args){
        // 嘗試1
        CGLibProxy cgLibProxy = new CGLibProxy();
        Hello helloProxy = cgLibProxy.getProxy(HelloImpl.class);
        helloProxy.say("Jack");
        // 嘗試2
        Hello helloProxy =CGLibProxy.getInstance().getProxy(HelloImpl.class);
        helloProxy.say("Jack");
    }
}

View Code

2、AOP技術

|-- interface Greeting 
|-- void sayHello(String name);
|-- GreetingImpl implements Greeting
|-- sayHello(String name){
    before();
    sysout("Hello!"+name);
    after();
}
|-- GreetingProxy implements Greeting
|-- GreetingImpl greetingImpl;
|-- GreetingProxy(GreetingImpl greetingImpl) -> this.greetingImpl = greetingImpl;
|-- sayHello(String name){
    before();
    greetingImpl.sayHello();
    after();
}
|-- before() -> sysout("Before");
|-- after() -> sysout("After");
|-- main(String[] args){
    Greeting greetingProxy = new GreetingProxy(new GreetingImpl());
    greetingProxy.sayHello("Jack");
}
|-- JDKDynamicProxy implements InvocationHandler {
    Object target; 
    JDKDynamicProxy (Object target){
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args){
        before();
        object result = method.invoke(target, args);
        after();
        return result;
    }
    public <T> T getProxy(){
        return (T)Proxy.newProxyInstance(
            target.getClass().getClassLoader(), 
            target.getClass.getInterfaces(), 
            this
        );
    }
    private void before(){
        sysout("Before");
    }
    private void after(){
        sysout("After");
    }
    
    main(String[] args){
        Greeting greeting = new JDKDynamicProxy(new GreetingImpl()).getProxy();
        greeting.sayHello("Jack");
    }
}
|-- CGLibProxy implements MethodInterceptor{
    private static CGLibProxy instance = new CGLibProxy();
        
    private CGLibProxy() {}
    
    public CGLibProxy getInstance(){
        return instance;
    }

    public <T> T getProxy(Class<T> cls){
        return (T) Enhancer.create(cls, this);
    }
    public Object inercept(Object obj, Method method, Object[] args, MethodProxy proxy){
        before();
        Object result = proxy.invokeSuper(obj, args);
        after();
        return result;
    }
    main(String[] args){
        Greeting greeting = CGLibProxy.getInstance().getProxy(GreetingImpl.class);
        greeting.sayHello("Jack");
    }
}

View Code

3、spring AOP技術

|-- GreetingBeforeAdvice implements MethodBeforeAdvice
    |-- before(Method method, Object[] args, Object target) throws Throwable -> sysout("Before");
|-- AfterReturningAdvice 
    |-- afterReturning(Object result, Method method, Object[] args, Object target) throws Throwable -> sysout("after");
|-- GreetingBeforeAndAfterAdvice implements MethodBeforeAdvice, AfterReturningAdvice
    |-- before(Method method, Object[] args, Object target) throws Throwable -> sysout("Before");
    |-- afterReturning(Object result, Method method, Object[] args, Object target) throws Throwable -> sysout("after");
|-- GreetingAroundAdvice implements MethodInterceptor // 環繞增強（org.aopalliance.intercept.MethodInterceptor，AOP聯盟）
    |-- Object invoke(MethodInvocation invocation){
        before();
        Object result = invocation.proceed();
        after();
    }
    |-- before() -> sysout("Before")
    |-- after() -> sysout("After")
|-- main (String[] args){
        ProxyFactory proxyFactory = new ProxyFactory(); // 建立代理工廠
        proxyFactory.setTarget(new GreetingImpl()); // 射入目標類物件
        // proxyFactory.addAdvice(new GreetingBeforeAdvice()); // 新增前置增強
        // proxyFactory.addAdvice(new AfterReturningAdvice()); // 新增後置增強
        // proxyFactory.addAdvice(new GreetingBeforeAndAfterAdvice()); // 新增前後置增強
        proxyFactory.addAdvice(new GreetingAroundAdvice()); // 新增環繞增強
        
        Greeting greeting = (Greeting)proxyFactory.getProxy(); // 從代理工廠獲取代理物件
        greeting.sayHello("Jack"); // 呼叫代理方法
    }
|-- 配置檔案-spring.xml
    <!-- 掃描指定包（將帶有@componet註解類自動定義為Spring bean） -->
    <context:componet-scan base-package="aop.demo"/> 
    <!-- 配置一個代理 --> 
    <bean id="greetingProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="interfaces" value="aop.Greeting"></property><!-- 需要代理的介面 -->
        <property name="target" value="greetingImpl"></property><!-- 介面實現類 -->
        <!-- <property name="target" value="greetingAroundAdvice"></property> -->
        <property name="interceptorNames">
            <list>
                <value>greetingAroundAdvice</value>
            </list>
        </property>
    </bean>
    
    spring2.5+特性，@Component
    @Component
    public calss GreetingImpl implements Greeting {
        ...
    }
    --> 
    <bean id="xxx" class="xxx">
|-- 客戶端呼叫
    |-- main(String[] args){
            ApplicationContext context = new ClassPathXmlApplicationContext("aop/demo/spring.xml");
            Greeting greeting = (Greeting)context.getBean("greetingProxy");
            greeting.sayHello("Jack");
        }
|-- 丟擲增強-ThrowsAdvice
    |-- GreetingThrowAdvice implements ThrowsAdvice {
            public void afterThrowing(Method method, Object[] args, Object target, Exception e){
                sysout("--------- Throw Exception ---------");
                sysout("Target Class: " + target.getClass().getName());
                sysout("Method Name: " + method.getName());
                sysout("Exception Message: " + e.getMessage());
                sysout("-----------------------------------");
            }
        }
|-- 引入增強
    |-- interface Apology 
        |-- void saySorry(String name);
    |-- @Component
        GreetingIntroAdvice extends DelegatingIntroductionInterceptor implements Apology {
            @Override 
            public Object invoke(MethodInvocation invocation) throws Throwable{
                return super.invoke(invocation);
            }
            
            @Overrice
            public void saySorry(String name){
                sysout("Sorry! + name);
            }
        }
    |-- 配置檔案-spring.xml
        <!-- 掃描指定包（將帶有@componet註解類自動定義為Spring bean） -->
        <context:componet-scan base-package="aop.demo"/> 
        <!-- 配置一個代理 --> 
        <bean id="greetingProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
            <property name="interfaces" value="aop.demo.Apology"></property><!-- 需要動態實現的介面 -->
            <property name="target" value="greetingImpl"></property><!-- 目標類 -->
            <property name="interceptorNames" value="greetingIntroAdvice"></property> <!-- 引入增強 -->
            <property name="proxyTargetClass" value="true"/> <!-- 代理目標類（預設為false，代理介面）-->
        </bean>
    |-- 呼叫
        |-- main(String[] args){
            ApplicationContext context = new ClassPathXmlApplicationContext("aop/demo/spring.xml");
            GeetingImpl greetingImpl = (GeetingImpl)context.getBean("greetingProxy"); // 轉型為目標類，而非它的介面
            greetingImpl.sayHello("Jack");
            
            Apology apology = (Apology) greetingImpl; // 將目標型別強制向上轉型為Apology介面（這就是引入增強給我們帶來的特性，也就是“介面動態實現”功能）
            apology.saySorry("Jack");
        }
|-- AOP 切面
    |-- @Component
        public class GreetingImpl implements Greeting {
            @Override
            public void sayHello(){
                sysout("Hello!" + name);
            }
            
            public void goodMorning(String name){
                sysout("Good Morning!" + name);
            }
            public void goodNight(String name){
                sysout("Good Night!" + name);
            }
        }
    |-- 配置檔案-spring.xml
        <!-- 掃描指定包（將帶有@componet註解類自動定義為Spring bean） -->
        <context:componet-scan base-package="aop.demo"/> 
        <!-- 配置一個切面 -->
        <bean id="greetingAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
            <property name="advice" value="greetingAroundAdvice"></property> <!-- 增強 -->
            <property name="pattern" value="aop.demo.GreetingImpl.good.*"></property> <!-- 切點（正則表示式） -->
        </bean>
        
        <!-- 配置一個代理 --> 
        <bean id="greetingProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
            <property name="target" value="greetingImpl"></property><!-- 目標類 -->
            <property name="interceptorNames" value="greetingAdvisor"></property><!-- 切面 -->
            <property name="proxyTargetClass" value="true"/> <!-- 代理目標類（預設為false，代理介面）-->
        </bean>
|-- AOP自動代理（每一個類都需要配置切面太麻煩，因此需要自動生成代理）
    |-- 配置檔案-spring.xml
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
        <property name="target" value="*Impl"></property><!-- 目標類 -->
        <property name="interceptorNames" value="greetingAroundAdvice"></property><!-- 增強 -->
        <property name="optimize" value="true"/> <!-- 是否對代理生成策略進行優化，預設是false -->
    </bean>
    *Impl -> 不清楚Bean實現了多少介面，不能代理介面，只能代理類。
    |-- 匹配到目標類的指定方法
        |-- 配置檔案-spring.xml
            <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
                <!-- <property name="target" value="*Impl">--></property><!-- 目標類 -->
                <!-- <property name="interceptorNames" value="greetingAroundAdvice"></property>--><!-- 增強 -->
                <property name="optimize" value="true"/> <!-- 是否對代理生成策略進行優化，預設是false -->
            </bean>
            --> 
            <bean id="greetingAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
                <property name="advice" ref="greetingAroundAdvice"></property> <!-- 增強 -->
                <property name="pattern" value="aop.demo.GreetingImpl.good.*"></property> <!-- 切點（正則表示式） -->
            </bean>
            <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
                <property name="optimize" value="true"/> <!-- 是否對代理生成策略進行優化，預設是false -->
            </bean>

總結：
    CGLib代理：建立代理速度慢，建立代理後執行速度快（系統初始化建立代理備用最佳）
    JDK動態代理：建立代理速度快，執行速度慢
    
|-- spring + AspectJ（Advisor）
|-- 普通demo
    |-- @Aspect
        @Component
        public class GreetingAspect {
            @Arount("execution(* aop.demo.GreetingImpl.*(..))")
            public Object around(ProceedingJoinPoint pjp) throws Throwable {
                before();
                Object result = pjp.proceed();
                after();
                return result;
            }
            public void before(){
                sysout("Before");
            }
            public void after(){
                sysout("after");
            }
        }
    |-- 配置檔案-spring.xml
        <!-- 掃描指定包（將帶有@componet註解類自動定義為Spring bean） -->
        <context:componet-scan base-package="aop.demo"/> 
        <aop:aspect-autoproxy proxy-target-class="true" />    
|-- 基於註解
    |-- @Target(ElementType.METHOD)
        @Retention(RetentionPolicy.RUNTIME)
        public @Interface Tag {
        }
    |-- @Aspect
        @Component
        public class GreetingAspect {
            @Arount("@Annotation(aop.demo.Tag)")
            public Object around(ProceedingJoinPoint pjp) throws Throwable {
                ...
            }
            ...
        }
    |-- @Component
        public class GreetingImpl implements Greeting {
            @Tag
            @Override 
            public void sayHello(String name){
                sysout("Hello!" + name);
            }
            ...
        }
    |-- 實現引入增強
        |-- @Aspect
            @Component
            public class GreetingAspect {
                
                @DelareParents(value="aop.demo.GreetingImpl",defaultImpl="ApologyImpl.class")
                private Apology apology;
            }
        |-- ApologyImpl implements Apology {
                
                @Override
                public void saySorry(String name){
                    sysout("Sorry!" + name);
                }
                main(String[] args){
                    ApplicationContext context = new ClassPathXmlApplicationContext("aop/demp/spring.xml");
                    Greeting greeting = context.getBean("greetingImpl");
                    greeting.sayHello("Jack");
                    Apology apology = (Apology) greeting;
                    apology.saySorry("Jack");
                }
            }
        
|-- 基於配置
    |-- 配置檔案-spring.xml
        <!-- 掃描指定包（將帶有@componet註解類自動定義為Spring bean） -->
        <context:componet-scan base-package="aop.demo"/>
        <beans ...>
            
            <bean id="greetingImpl" class="aop.demo.GreetingImpl" />
            <bean id="greetingAspect" class="aop.demo.GreetingAspect" />
            <aop:config>
                <aop:aspect ref="greetingAspect">
                    <aop:around method="around" pointcut="execution (* aop.demo.GreetingImpl.*(..))"/>
                </aop:aspect>
            </aop:config>
        </beans>

View Code

4、開發aop框架

|-- 定義註解類：
|-- @Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @Interface Aspect {
    Class<? extends Annotion> value();
}
|-- 搭建代理框架
|-- interface Proxy { 代理介面
    // 執行鏈式代理：可將多個代理通過一條鏈子串起來，一個個地去執行，執行順序取決於新增到鏈上的先後順序
    Object doProxy(ProxyChain proxyChain) throws Throwable;
}
|-- class ProxyChain // 代理鏈
|-- Class<?> targetClass;
|-- Object targetObject;
}-- Method targetMethod;
|-- MethodProxy methodProxy;
}-- Object[] methodParams;
|-- List<Proxy> proxyList = new ArrayList<>();
|-- int proxyIndex=0;
|-- ProxChain(Class<?> targetClass,Object targetObject,Method targetMethod,MethodProxy methodProxy,Object[] methodParams,List<Proxy> proxyList){
        this.targetClass = targetClass;
        ...
    }
|-- getMethodParams() -> return methodParams;
|-- getTargetClass() -> return targetClass;
|-- getTargetMethod() -> return targetMethod;
|-- Object doProxyChain() throws throwable{
        Object methodResult;
        if (proxyIndex < proxyList.size()){
            methodResult = proxyList.get(proxyIndex++).doProxy();
        } else {
            methodResult = methodProxy.invokeSuper(targetObject, methodParams);
        }
        return methodResult;
    }
|-- 新增pom.xml依賴
<!-- cglib 依賴-->
<grouId>cglib<groupId>...
|-- class ProxyManger // 代理管理類
|-- <T> T createProxy(final Class<?> targetClass, final List<Proxy> proxyList){
        return (T) Enhancer.create(targetClass, new MethodInterceptor(){
            @Overrice
            public Object intercept(Object targetObject, Method targetMethod, 
                Object[] methodParams, MethodProxy methodProxy){
                return new ProxyChain(targetClass, targetObject, targetMethod, methodProxy, methodParams, proxyList);
            }
        });
    }
|-- public abstract calss AspectProxy implements Proxy { // 切面代理
    @Override
    public final Object doProxy(ProxyChain proxyChain) throws throwable {
        Object result = null;
        Class<?> cls = proxyChain.getTargetClass();
        Method method = proxyChain.getTargetMethod();
        Object[] params = proxyChain.getMethodParams();
        begin();
        try {
            if (intercept(cls, method, params)){
                before(cls, method, params);
                result = proxyChain.doProxyChain();
                after(cls, method, params);
            } else {
                return proxyChain.doProxyChain();
            }
        } catch(Exception e){
            logger.error("proxy failure", e);
            error(cls, method, params, e);
            throw e;
        } finally {
            end();
        }
    }
    public void begin(){
    }
    public void end(){
    }
    public boolean intercept(Class<?> cls, Method method, Object[] params) throws Throwable {
        return true;
    }
    public void before(Class<?> cls, Method method, Object[] params) throws Throwable {
    }
    public void after(Class<?> cls, Method method, Object[] params) throws Throwable {
    }
    public void error(Class<?> cls, Method method, Object[] params, Throwable e){
    }
}
|-- @Aspect(Controller.class)
ControllerAspect extends AspectProxy{ // 攔截Controller    所有方法
    private long begin;
    @Override
    public void before(Class<?> cls, Method method, Object[] params) throws Throwable {
        begin = System.currentTimeMillis();
    }
    @Override
    public void after(Class<?> cls, Method method, Object[] params) throws Throwable {
        sysout(System.currentTimeMillis()-begin);
    }
}
|-- BeanHelper {
    ...
    // 設定bean例項 
    public static void setBean(Class<?> cls, Object obj){
        BEAN_MAP.put(cls, obj);
    }
}    
|-- ClassHelper {
    ...
    // 獲取某父類（或介面）的所有子類（或實現類）
    public static Set<Class<?>> getClassSetBySuper(Class<?> superClass){
        Set<Class<?>> classSet = new HashSet<Classs<?>();
        for(Class<?> cls : CLASS_SET){
            if (superClass.isAssignableFrom(cls) && !superClass.equals(cls)){
                classSet.add(cls);
            }
        }
    } 
    // 獲取應用包名下帶有註解的所有類
    public static Set<Class<?>> getClassSetByAnnotation(Class<? extends Annotation> annotionClass){
        Set<Class<?>> classSet = new HashSet<Classs<?>();
        for(Class<?> cls : CLASS_SET){
            if (superClass.isAnnotationPresent(annotionClass)){
                classSet.add(cls);
            }
        }
    }
    ...
}
|-- AopHelper {
    ...
    private static Set<Class<?>> createTargetClassSet(Aspect aspect) throws Exception {
        Set<Class<?>> targetClassSet = new HashSet<Class<?>>();
        Class<? extends annotation> annotation = aspect.value();
        if (annotation != null && !annotation.equals(Aspect.class)){
            targetClassSet.addAll(ClassHelper.getClassSetByAnnotation(annotation));
        }
        return targetClassSet;
    }
    private static Map<Class<?>>,Set<Class<?>>> createProxyMap() throws Exception {
        Map<Class<?>>,Set<Class<?>>> proxyMap = new HashMap<Class<?>>,Set<Class<?>>>();
        Set<Class<?>> proxyClassSet = ClassHelper.getClassSetByAnnotation(AspectProxy.class);
        for(Class<?> proxyClass : proxyClassSet){
            if (proxyClass.isAnnotationPresent(Aspect.class)){
                Aspect aspect = proxyClass.getAnnotation(Aspect.class);
                Set<Class<?>> targetClassSet = createTargetClassSet(aspect);
                proxyMap.put(proxyClass, targetClassSet);
            }
        }
        return proxyMap;
    }    
    private static Map<Class<?>,List<Proxy>> createTargetMap(Map<Class<?>>,Set<Class<?>>> proxyMap) throws Exception {
        Map<Class<?>,List<Proxy>> targetMap = new HashMap<Class<?>,List<Proxy>>();
        for(Map.Entry<Class<?>>,Set<Class<?>>> proxyEntry : proxyMap.entrySet()){
            Class<?> proxyClass = proxyEntry.getKey();
            Set<Class<?> targetClassSet = proxyEntry.getValue();
            for(Class<?> targetClass : targetClassSet){
                Proxy proxy = (Proxy) targetClass.newInstance();
                if (targetMap.contains(targetClass)){
                    targetMap.get(targetClass).add(proxy);
                } else {
                    List<Proxy> proxyList = new ArrayList<Proxy>();
                    proxyList.add(proxy);
                    targetMap.put(targetClass, proxyList);
                }
            }
        }
    }
    
    static {
        try {
            Map<Class<?>>,Set<Class<?>>> proxyMap = createProxyMap();
            Map<Class<?>,List<Proxy>> targetMap = createTargetMap(proxyMap);
            for(Map.Entry<Class<?>,List<Proxy>> targetEntry : targetMap.etrySet()){
                Class<?> targetClass =targetEntry.getKey();
                List<Proxy> proxyList = targetEntry.getValue();
                Object proxy = ProxyManager.createProxy(targetClass, proxyList);
                BeanHelper.setBean(targetClass, proxy);
            }
        } catch(Exception e){
            Logger.error("aop failure", e);
        }
    }
}
|-- HelperLoader {
    public static void init(){
    
        Class<?>[] classList = {
            ClassHelper.class, 
            BeanHelper.class,
            AopHelper.class,
            IocHelper.class,
            ControllerHelper.class
        };
        for(Class<?> cls : classList){
            ClassUtil.loadClass(cls.getName(), true);
        }
    }
}

View Code

spring原始碼AOP解析

1、代理技術（靜態代理、JDK動態代理、CGLib代理）靜態代理： |-- Hello |-- void say(String name); |-- HelloImpl implements Hello { voiv say(String name){ sysout("He

《Spring原始碼深度解析》讀後感

大概三週看完《Spring原始碼深度解析》寫下一篇讀後感玩首先高度概括：內容過於豐富重點不突出本書共分8個模組 1、XML解析部分非常全面，各種配置方法，解析步驟都有介紹，這裡其實就是些巢狀的呼叫，Spring原始碼肯定比自己寫的優美。

《Spring原始碼深度解析》學習筆記

《Spring原始碼深度解析》學習筆記——Spring的整體架構與容器的基本實現 spring框架是一個分層架構，它包含一系列的功能要素，並被分為大約20個模組，如下圖所示這些模組被總結為以下幾個部分： Core Container Core Container

Spring原始碼深度解析-1、Spring核心類簡單介紹

在更新JAVA基礎原始碼學習的同時，也有必要把Spring抓一抓，以前對於spring的程度僅在於使用，以及一點IOC/AOP的概念，具體深層的瞭解不是很深入，每次看了一點原始碼就看不下去，然後一轉眼都忘記看了啥。所以這次專門買了書，來細細品味下Spring。希望能從這一波學習中加強自己

Spring原始碼深度解析，事務案例講解高階

Spring的整體架構Spring框架是一個分層架構，它包含一系列的功能要素，並被分為大約20個模組，如下圖所示這些模組被總結為以下幾個部分： Core Container Core Container(核心容器)包含有Core、Beans、Context和Expression Lan

spring原始碼深度解析筆記（三）

之前提到在xmlBeanFactory建構函式中呼叫了XmlBeanDefinitionReader型別的reader屬性提供的方法this.reader.loadBeanDefinitions(resource),這就是載入整個資源載入的切入點。當進入XmlBeanDe

spring原始碼深度解析筆記（四）

DTD與XSD的區別 DTD（Document Type Definition）即文件型別定義，是一種XML約束模式語言，是XML檔案的驗證機制，是屬於XML檔案組成的一部分。DTD是一種保證XML文件格式正確的有效方法，可以通過比較XML文件和DTD檔案來看

spring原始碼-aop動態代理-5.3

　　一、動態代理，這是一個很強大的東西哦。研發過程中我們會常用很多業務類，但是存在一個問題。如何在不修改原始碼邏輯的情況下，加入自己的相關邏輯。比如異常處理，日誌記錄等！　　二、Java動態代理的兩種方式JDK、CGLIB 　　三、動態代理的例子　　1）需要代理的類　 public inte

《Spring原始碼深度解析》pdf附網盤下載連結送給還在迷茫的你

技術書閱讀方法論一.速讀一遍（最好在1~2天內完成）人的大腦記憶力有限，在一天內快速看完一本書會在大腦裡留下深刻印象，對於之後複習以及總結都會有特別好的作用。對於每一章的知識，先閱讀標題，弄懂大概講的是什麼主題，再去快速看一遍，不懂也沒有關係，但是一定要在不懂的

Spring原始碼——AOP

前言內容主要參考自《Spring原始碼深度解析》一書，算是讀書筆記或是原書的補充。進入正文後可能會引來各種不適，畢竟閱讀原始碼是件極其痛苦的事情。面向物件程式設計為什麼需要面向切面程式設計（AOP），AOP又是什麼？ AspectJ 和 Spring

Spring原始碼註解解析day03

開啟AOP的註解--》@EnableAspectJAutoProxy @EnableAspectJAutoProxy詳情：裡面匯入了AspectJAutoProxyRegistrar.class類，該類是幹嘛的呢？原來是一個註冊類，@EnableAspectJAut

Spring原始碼註解解析day04

今天主要是來記錄一下Spring的事務控制的原理、以及BeanPostProcessor、BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor、ApplicationListener 一、Spring的宣告

《spring原始碼深度解析》第二章

1：容器基本用法 2：功能分析 3：工程搭建 4：spring的結構組成（beans包的層級結構、核心類介紹） 5：容器的基礎XMLBeanFactory（配置檔案封裝、載入

【Spring原始碼--AOP的實現】（一）AopProxy代理物件的建立

public Object getProxy(ClassLoader classLoader) { if (logger.isDebugEnabled()) { logger.debug("Creating CGLIB2 proxy: target source is " + this.a

Spring原始碼深度解析-3、從XmlBeanFactory到程式設計式使用IOC容器

XmlBeanFactory簡述 XmlBeanFactory繼承自DefaultListableBeanFactory，因此他擁有一個IOC容器最基本的功能，包括getBean，getBeanDefinationsName，除此之外，通過這個容器的名稱也能瞭解到這個容器是可以讀取以Xm

Spring原始碼深度解析-2、IOC容器的設計

前言前面暫時結束jvm與java基礎的整理，今天開始整理spring的內容。 demo 先從一個demo開始，最開始學spring，大家都寫過這樣的demo。 //實體類 package com.ycf.test; public class User { private

Spring原始碼-AOP(五)-ProxyFactoryBean

上一章中我們分析了ProxyFactory，它是Spring AOP核心的底層實現。然而硬編碼的方式還是過於繁瑣且不易使用，本章我們將討論ProxyFactoryBean，它結合了ProxyFactory和Ioc中的FactoryBean擴充套件，使得可以通過XML配置的方式

Spring原始碼深度解析總結（3）—— 配置檔案的讀取和Bean的載入（一）

上一篇總結了Spring利用Resource介面對配置檔案的封裝，接下來我們要看看Spring對封裝好的資源是如何解析的，以及如何利用解析出的資訊載入Bean的。BeanFactory bf = new XmlBeanFactory(new ClassPathResoure(

Spring原始碼深度解析（四）容器的基礎XmlBeanFactory

現在我們已經對Srping的容器有了一個大概的瞭解，儘管很多地方還很迷糊，但是不要緊，下面我們開始探討每個步驟的詳細實現。接下來我們要深入分析以下程式碼的實現： BeanFactory bf = new XmlBeanFactory(new ClassPathResourc

Spring原始碼深度解析（一）Spring的整體架構

spring框架是一個分層架構，它包含一系列的功能要素，被分為大約20個模組，如下圖所示： spring整體架構圖這些模組被總結為以下幾個部分：（1）Core Container Core

spring原始碼AOP解析

相關推薦