Spring【AOP模組】就是這麼簡單

Java3y發表於2018-03-14

Spring

前言

到目前為止，已經簡單學習了Spring的Core模組、....於是我們就開啟了Spring的AOP模組了...在講解AOP模組之前，首先我們來講解一下cglib代理、以及怎麼手動實現AOP程式設計

cglib代理

在講解cglib之前，首先我們來回顧一下靜態代理和動態代理....我之前就寫過了靜態代理、動態代理的博文：blog.csdn.net/hon_3y/arti…

由於靜態代理需要實現目標物件的相同介面，那麼可能會導致代理類會非常非常多....不好維護---->因此出現了動態代理

動態代理也有個約束：目標物件一定是要有介面的，沒有介面就不能實現動態代理.....----->因此出現了cglib代理

cglib代理也叫子類代理，從記憶體中構建出一個子類來擴充套件目標物件的功能！

CGLIB是一個強大的高效能的程式碼生成包，它可以在執行期擴充套件Java類與實現Java介面。它廣泛的被許多AOP的框架使用，例如Spring AOP和dynaop，為他們提供方法的interception（攔截）。

編寫cglib代理

接下來我們就講講怎麼寫cglib代理：

需要引入cglib – jar檔案，但是spring的核心包中已經包括了cglib功能，所以直接引入spring-core-3.2.5.jar即可。
引入功能包後，就可以在記憶體中動態構建子類
代理的類不能為final，否則報錯【在記憶體中構建子類來做擴充套件，當然不能為final，有final就不能繼承了】
目標物件的方法如果為final/static, 那麼就不會被攔截，即不會執行目標物件額外的業務方法。

//需要實現MethodInterceptor介面
public class ProxyFactory implements MethodInterceptor{
	
	// 維護目標物件
	private Object target;
	public ProxyFactory(Object target){
		this.target = target;
	}
	
	// 給目標物件建立代理物件
	public Object getProxyInstance(){
		//1. 工具類
		Enhancer en = new Enhancer();
		//2. 設定父類
		en.setSuperclass(target.getClass());
		//3. 設定回撥函式
		en.setCallback(this);
		//4. 建立子類(代理物件)
		return en.create();
	}
	

	@Override
	public Object intercept(Object obj, Method method, Object[] args,
			MethodProxy proxy) throws Throwable {
		
		System.out.println("開始事務.....");
		
		// 執行目標物件的方法
		//Object returnValue = method.invoke(target, args);
		 proxy.invokeSuper(object, args); 
		System.out.println("提交事務.....");
		
		return returnValue;
	}

}

複製程式碼

測試：


public class App {

    public static void main(String[] args) {

        UserDao userDao = new UserDao();

        UserDao factory = (UserDao) new ProxyFactory(userDao).getProxyInstance();

        factory.save();
    }
}

複製程式碼

使用cglib就是為了彌補動態代理的不足【動態代理的目標物件一定要實現介面】

手動實現AOP程式設計

AOP 面向切面的程式設計：

AOP可以實現“業務程式碼”與“關注點程式碼”分離

下面我們來看一段程式碼：


// 儲存一個使用者
public void add(User user) { 
		Session session = null; 
		Transaction trans = null; 
		try { 
			session = HibernateSessionFactoryUtils.getSession();   // 【關注點程式碼】
			trans = session.beginTransaction();    // 【關注點程式碼】
			 
			session.save(user);     // 核心業務程式碼
			 
			trans.commit();     //…【關注點程式碼】

		} catch (Exception e) {     
			e.printStackTrace(); 
			if(trans != null){ 
				trans.rollback();   //..【關注點程式碼】

			} 
		} finally{ 
			HibernateSessionFactoryUtils.closeSession(session);   ////..【關注點程式碼】

		} 
   } 
複製程式碼

關注點程式碼，就是指重複執行的程式碼。
業務程式碼與關注點程式碼分離，好處？
- 關注點程式碼寫一次即可；
- 開發者只需要關注核心業務；
- 執行時期，執行核心業務程式碼時候動態植入關注點程式碼；【代理】

案例分析：

IUser介面


public interface IUser {

    void save();
}

複製程式碼

我們一步一步來分析，首先我們的UserDao有一個save()方法，每次都要開啟事務和關閉事務


//@Component  -->任何地方都能用這個
@Repository  //-->這個在Dao層中使用
    public class UserDao {

    public void save() {

        System.out.println("開始事務");
        System.out.println("DB:儲存使用者");
        System.out.println("關閉事務");

    }


}
複製程式碼

在剛學習java基礎的時候，我們知道：如果某些功能經常需要用到就封裝成方法：


//@Component  -->任何地方都能用這個
@Repository  //-->這個在Dao層中使用
    public class UserDao {

    public void save() {

        begin();
        System.out.println("DB:儲存使用者");
        close();
        
    }

    public void begin() {
        System.out.println("開始事務");
    }
    public void close() {
        System.out.println("關閉事務");
    }
}
複製程式碼

現在呢，我們可能有多個Dao，都需要有開啟事務和關閉事務的功能，現在只有UserDao中有這兩個方法，重用性還是不夠高。因此我們抽取出一個類出來


public class AOP {
    
    public void begin() {
        System.out.println("開始事務");
    }
    public void close() {
        System.out.println("關閉事務");
    }
}

複製程式碼

在UserDao維護這個變數，要用的時候，呼叫方法就行了。


@Repository  //-->這個在Dao層中使用
public class UserDao {


    AOP aop;

    public void save() {

        aop.begin();
        System.out.println("DB:儲存使用者");
        aop.close();

    }
    
}

複製程式碼

現在的開啟事務、關閉事務還是需要我在userDao中手動呼叫。還是不夠優雅。。我想要的效果：當我在呼叫userDao的save()方法時，動態地開啟事務、關閉事務。因此，我們就用到了代理。當然了，真正執行方法的都是userDao、要幹事的是AOP，因此在代理中需要維護他們的引用。

public class ProxyFactory {
    //維護目標物件
    private static Object target;

    //維護關鍵點程式碼的類
    private static AOP aop;
    public static Object getProxyInstance(Object target_, AOP aop_) {

        //目標物件和關鍵點程式碼的類都是通過外界傳遞進來
        target = target_;
        aop = aop_;

        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        aop.begin();
                        Object returnValue = method.invoke(target, args);
                        aop.close();

                        return returnValue;
                    }
                }
        );
    }
}



複製程式碼

工廠靜態方法：

把AOP加入IOC容器中




//把該物件加入到容器中
@Component
public class AOP {

    public void begin() {
        System.out.println("開始事務");
    }
    public void close() {
        System.out.println("關閉事務");
    }
}
複製程式碼

把UserDao放入容器中


@Component
public class UserDao {

    public void save() {

        System.out.println("DB:儲存使用者");

    }

}
複製程式碼

在配置檔案中開啟註解掃描,使用工廠靜態方法建立代理物件


<?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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       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="proxy" class="aa.ProxyFactory" factory-method="getProxyInstance">
        <constructor-arg index="0" ref="userDao"/>
        <constructor-arg index="1" ref="AOP"/>
    </bean>

    <context:component-scan base-package="aa"/>





</beans>
複製程式碼

測試，得到UserDao物件，呼叫方法


public class App {

    public static void main(String[] args) {

        ApplicationContext ac =
                new ClassPathXmlApplicationContext("aa/applicationContext.xml");


        IUser iUser = (IUser) ac.getBean("proxy");

        iUser.save();



    }
}

複製程式碼

工廠非靜態方法

上面使用的是工廠靜態方法來建立代理類物件。我們也使用一下非靜態的工廠方法建立物件。


package aa;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * Created by ozc on 2017/5/11.
 */

public class ProxyFactory {

    public Object getProxyInstance(final Object target_, final AOP aop_) {

        //目標物件和關鍵點程式碼的類都是通過外界傳遞進來

        return Proxy.newProxyInstance(
                target_.getClass().getClassLoader(),
                target_.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        aop_.begin();
                        Object returnValue = method.invoke(target_, args);
                        aop_.close();

                        return returnValue;
                    }
                }
        );
    }
}

複製程式碼

配置檔案:先建立工廠，再建立代理類物件

<?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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       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="factory" class="aa.ProxyFactory"/>


    <!--通過工廠建立代理-->
    <bean id="IUser" class="aa.IUser" factory-bean="factory" factory-method="getProxyInstance">
        <constructor-arg index="0" ref="userDao"/>
        <constructor-arg index="1" ref="AOP"/>
    </bean>


    <context:component-scan base-package="aa"/>


</beans>
複製程式碼

AOP的概述

Aop： aspect object programming 面向切面程式設計

功能：讓關注點程式碼與業務程式碼分離！
面向切面程式設計就是指： 對很多功能都有的重複的程式碼抽取，再在執行的時候往業務方法上動態植入“切面類程式碼”。

關注點：

重複程式碼就叫做關注點。


// 儲存一個使用者
public void add(User user) { 
		Session session = null; 
		Transaction trans = null; 
		try { 
			session = HibernateSessionFactoryUtils.getSession();   // 【關注點程式碼】
			trans = session.beginTransaction();    // 【關注點程式碼】
			 
			session.save(user);     // 核心業務程式碼
			 
			trans.commit();     //…【關注點程式碼】

		} catch (Exception e) {     
			e.printStackTrace(); 
			if(trans != null){ 
				trans.rollback();   //..【關注點程式碼】

			} 
		} finally{ 
			HibernateSessionFactoryUtils.closeSession(session);   ////..【關注點程式碼】

		} 
   } 
複製程式碼

切面：

關注點形成的類，就叫切面(類)！


public class AOP {

    public void begin() {
        System.out.println("開始事務");
    }
    public void close() {
        System.out.println("關閉事務");
    }
}

複製程式碼

切入點：

執行目標物件方法，動態植入切面程式碼。
可以通過切入點表示式，指定攔截哪些類的哪些方法；給指定的類在執行的時候植入切面類程式碼。

切入點表示式：

指定哪些類的哪些方法被攔截

使用Spring AOP開發步驟

1） 先引入aop相關jar檔案 （aspectj aop優秀元件）

spring-aop-3.2.5.RELEASE.jar 【spring3.2原始碼】
aopalliance.jar 【spring2.5原始碼/lib/aopalliance】
aspectjweaver.jar 【spring2.5原始碼/lib/aspectj】或【aspectj-1.8.2\lib】
aspectjrt.jar 【spring2.5原始碼/lib/aspectj】或【aspectj-1.8.2\lib】

注意： 用到spring2.5版本的jar檔案，如果用jdk1.7可能會有問題。

需要升級aspectj元件，即使用aspectj-1.8.2版本中提供jar檔案提供。

2） bean.xml中引入aop名稱空間

xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

引入jar包

引入4個jar包：

引入名稱空間


<?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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       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">
    
</beans>
複製程式碼

註解方式實現AOP程式設計

我們之前手動的實現AOP程式設計是需要自己來編寫代理工廠的**，現在有了Spring，就不需要我們自己寫代理工廠了。Spring內部會幫我們建立代理工廠**。

也就是說，不用我們自己寫代理物件了。

因此，我們只要關心切面類、切入點、編寫切入表示式指定攔截什麼方法就可以了！

還是以上一個例子為案例，使用Spring的註解方式來實現AOP程式設計

在配置檔案中開啟AOP註解方式


<?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:p="http://www.springframework.org/schema/p"
       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">


    <context:component-scan base-package="aa"/>

    <!-- 開啟aop註解方式 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>
複製程式碼

程式碼：

切面類


@Component
@Aspect//指定為切面類
public class AOP {


	//裡面的值為切入點表示式
    @Before("execution(* aa.*.*(..))")
    public void begin() {
        System.out.println("開始事務");
    }


    @After("execution(* aa.*.*(..))")
    public void close() {
        System.out.println("關閉事務");
    }
}
複製程式碼

UserDao實現了IUser介面


@Component
public class UserDao implements IUser {

    @Override
    public void save() {
        System.out.println("DB:儲存使用者");
    }

}
複製程式碼

IUser介面


public interface IUser {
    void save();
}

複製程式碼

測試程式碼：


public class App {

    public static void main(String[] args) {

        ApplicationContext ac =
                new ClassPathXmlApplicationContext("aa/applicationContext.xml");

		//這裡得到的是代理物件....
        IUser iUser = (IUser) ac.getBean("userDao");

        System.out.println(iUser.getClass());

        iUser.save();
        
    }
}
複製程式碼

目標物件沒有介面

上面我們測試的是UserDao有IUser介面，內部使用的是動態代理...那麼我們這次測試的是目標物件沒有介面

OrderDao沒有實現介面


@Component
public class OrderDao {

    public void save() {

        System.out.println("我已經進貨了！！！");
        
    }
}
複製程式碼

測試程式碼：



public class App {

    public static void main(String[] args) {

        ApplicationContext ac =
                new ClassPathXmlApplicationContext("aa/applicationContext.xml");

        OrderDao orderDao = (OrderDao) ac.getBean("orderDao");

        System.out.println(orderDao.getClass());

        orderDao.save();

    }
}


複製程式碼

優化和AOP註解API

API：

@Aspect 指定一個類為切面類
@Pointcut("execution( cn.itcast.e_aop_anno..(..))") 指定切入點表示式*
@Before("pointCut_()") 前置通知: 目標方法之前執行
@After("pointCut_()") 後置通知：目標方法之後執行（始終執行）
@AfterReturning("pointCut_()") 返回後通知： 執行方法結束前執行(異常不執行)
@AfterThrowing("pointCut_()") 異常通知: 出現異常時候執行
@Around("pointCut_()") 環繞通知：環繞目標方法執行
測試：

	
	// 前置通知 : 在執行目標方法之前執行
	@Before("pointCut_()")
	public void begin(){
		System.out.println("開始事務/異常");
	}
	
	// 後置/最終通知：在執行目標方法之後執行  【無論是否出現異常最終都會執行】
	@After("pointCut_()")
	public void after(){
		System.out.println("提交事務/關閉");
	}
	
	// 返回後通知： 在呼叫目標方法結束後執行 【出現異常不執行】
	@AfterReturning("pointCut_()")
	public void afterReturning() {
		System.out.println("afterReturning()");
	}
	
	// 異常通知： 當目標方法執行異常時候執行此關注點程式碼
	@AfterThrowing("pointCut_()")
	public void afterThrowing(){
		System.out.println("afterThrowing()");
	}
	
	// 環繞通知：環繞目標方式執行
	@Around("pointCut_()")
	public void around(ProceedingJoinPoint pjp) throws Throwable{
		System.out.println("環繞前....");
		pjp.proceed();  // 執行目標方法
		System.out.println("環繞後....");
	}

複製程式碼

優化

我們的程式碼是這樣的：每次寫Before、After等，都要重寫一次切入點表示式，這樣就不優雅了。


    @Before("execution(* aa.*.*(..))")
    public void begin() {
        System.out.println("開始事務");
    }


    @After("execution(* aa.*.*(..))")
    public void close() {
        System.out.println("關閉事務");
    }

複製程式碼

於是乎，我們要使用@Pointcut這個註解，來指定切入點表示式，在用到的地方中，直接引用就行了！

那麼我們的程式碼就可以改造成這樣了：


@Component
@Aspect//指定為切面類
public class AOP {


    // 指定切入點表示式，攔截哪個類的哪些方法
    @Pointcut("execution(* aa.*.*(..))")
    public void pt() {

    }

    @Before("pt()")
    public void begin() {
        System.out.println("開始事務");
    }


    @After("pt()")
    public void close() {
        System.out.println("關閉事務");
    }
}


複製程式碼

XML方式實現AOP程式設計

首先，我們把所有的註解都去掉...

XML檔案配置

<?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:p="http://www.springframework.org/schema/p"
       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">


    <!--物件例項-->
    <bean id="userDao" class="aa.UserDao"/>
    <bean id="orderDao" class="aa.OrderDao"/>

    <!--切面類-->
    <bean id="aop" class="aa.AOP"/>

    <!--AOP配置-->
    <aop:config >

        <!--定義切入表示式，攔截哪些方法-->
        <aop:pointcut id="pointCut" expression="execution(* aa.*.*(..))"/>

        <!--指定切面類是哪個-->
        <aop:aspect ref="aop">

            <!--指定來攔截的時候執行切面類的哪些方法-->
            <aop:before method="begin" pointcut-ref="pointCut"/>
            <aop:after method="close" pointcut-ref="pointCut"/>

        </aop:aspect>
    </aop:config>

    
</beans>

複製程式碼

測試：


public class App {

    @Test
    public  void test1() {

        ApplicationContext ac =
                new ClassPathXmlApplicationContext("aa/applicationContext.xml");

        OrderDao orderDao = (OrderDao) ac.getBean("orderDao");

        System.out.println(orderDao.getClass());

        orderDao.save();

    }

    @Test
    public  void test2() {

        ApplicationContext ac =
                new ClassPathXmlApplicationContext("aa/applicationContext.xml");

        IUser userDao = (IUser) ac.getBean("userDao");

        System.out.println(userDao.getClass());

        userDao.save();

    }
}

複製程式碼

測試OrderDao

測試UserDao

切入點表示式

切入點表示式主要就是來配置攔截哪些類的哪些方法

查官方文件

..我們去文件中找找它的語法...

在文件中搜尋:execution(

語法解析

那麼它的語法是這樣子的：


execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

複製程式碼

符號講解：

?號代表0或1，可以不寫
“*”號代表任意型別，0或多
方法引數為..表示為可變引數

引數講解：

modifiers-pattern?【修飾的型別，可以不寫】
ret-type-pattern【方法返回值型別，必寫】
declaring-type-pattern?【方法宣告的型別，可以不寫】
name-pattern(param-pattern)【要匹配的名稱，括號裡面是方法的引數】
throws-pattern?【方法丟擲的異常型別，可以不寫】

官方也有給出一些例子給我們理解：

測試程式碼


		<!-- 【攔截所有public方法】 -->
		<!--<aop:pointcut expression="execution(public * *(..))" id="pt"/>-->
		
		<!-- 【攔截所有save開頭的方法 】 -->
		<!--<aop:pointcut expression="execution(* save*(..))" id="pt"/>-->
		
		<!-- 【攔截指定類的指定方法, 攔截時候一定要定位到方法】 -->
		<!--<aop:pointcut expression="execution(public * cn.itcast.g_pointcut.OrderDao.save(..))" id="pt"/>-->
		
		<!-- 【攔截指定類的所有方法】 -->
		<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.*(..))" id="pt"/>-->
		
		<!-- 【攔截指定包，以及其自包下所有類的所有方法】 -->
		<!--<aop:pointcut expression="execution(* cn..*.*(..))" id="pt"/>-->
		
		<!-- 【多個表示式】 -->
		<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) || execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
		<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) or execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
		<!-- 下面2個且關係的，沒有意義 -->
		<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) &amp;&amp; execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
		<!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.UserDao.save()) and execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
		
		<!-- 【取非值】 -->
		<!--<aop:pointcut expression="!execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>-->
複製程式碼

如果文章有錯的地方歡迎指正，大家互相交流。習慣在微信看技術文章，想要獲取更多的Java資源的同學，可以關注微信公眾號:Java3y

Spring【DAO模組】就是這麼簡單
2018-03-15
Spring
Spring AOP就是這麼簡單啦
2018-05-24
Spring
Spring【依賴注入】就是這麼簡單
2018-03-14
Spring依賴注入
jdbc就是這麼簡單
2019-03-03
JDBC
WebSocket就是這麼簡單
2019-03-04
Web
WebService就是這麼簡單
2019-03-04
Web
jwt 就是這麼簡單
2018-08-14
JWT
ThreadLocal就是這麼簡單
2018-04-03
thread
SpringBoot就是這麼簡單
2018-03-20
Spring Boot
Activiti就是這麼簡單
2018-03-19
promise原理就是這麼簡單
2018-09-10
Promise
建造者模式就是這麼簡單
2019-05-12
模式
搞定JVM垃圾回收就是這麼簡單
2019-03-04
JVM
Mybatis【配置檔案】就是這麼簡單
2019-02-25
MyBatis
HashMap就是這麼簡單【原始碼剖析】
2018-04-10
HashMap原始碼
包裝模式就是這麼簡單啦
2019-03-04
模式
二叉樹就是這麼簡單
2018-03-24
二叉樹
Spring【AOP模組】知識要點
2021-09-09
Spring
kotlin代理模式就是這麼簡單(委託)
2018-07-13
Kotlin模式
LinkedHashMap，原始碼解讀就是這麼簡單
2019-09-06
HashMap原始碼
使用plantuml，業務交接就是這麼簡單
2021-12-14
Java多執行緒就是這麼簡單
2020-12-14
Java執行緒
多執行緒之死鎖就是這麼簡單
2018-05-06
執行緒
爬蟲，其實本就是這麼簡單
2019-08-19
爬蟲
聊天三部曲成交就是這麼簡單
2022-05-07
spring之AOP的概念及簡單案例
2023-05-20
Spring
簡單聊聊模組
2019-03-25
Flutter多平臺適配機制就是這麼簡單
2019-12-22
Flutter
Paramiko模組簡單使用
2018-08-22
深入理解JVM——（二）搞定JVM垃圾回收就是這麼簡單
2019-01-20
JVM
瞧，Vue3.x最小原型系統就是這麼簡單
2022-02-15
Vue原型
Spring(2)-AOP簡介
2021-10-19
Spring
Spring Boot實際專案用簡單的AOP
2019-05-04
Spring Boot
樸素貝葉斯入門例項之就是這麼簡單
2019-02-21
想要將視訊轉換成GIF檔案？就是這麼簡單
2022-01-06
設計遊戲就是這麼簡單（一）：最重要的兩點
2021-03-03
遊戲
python inspect模組簡單使用
2020-11-19
Python
簡單選擇排序就是簡單~~~
2021-05-12
排序