代理模式、實現AOP編程

代理模式

概述

代理（Proxy）是一種設計模式，提供了對目標對象另外的訪問方式；即通過代理訪問目標對象。這樣好處：可以在目標對象實現的基礎上，增強額外的功能操作。(擴展目標對象的功能)。
代理模式的關鍵點：代理對象與目標對象。

靜態代理

靜態代理，
代理對象，要實現與目標對象一樣的接口；
舉例:保存用戶(模擬)
Dao , 直接保存
DaoProxy, 給保存方法添加事務處理

// 接口
public interface IUserDao {

   void save();
}

/**
 * 目標對象
 */
public class UserDao implements IUserDao{

   @Override
   public void save() {
      System.out.println("-----已經保存數據------");
   }

}

/**
 * 代理對象（靜態代理）
 *    代理對象要實現與目標對象一樣的接口
 */
public class UserDaoProxy implements IUserDao{

   // 使用構造函數接收保存目標對象
   private IUserDao target;
   public UserDaoProxy(IUserDao target) {
      this.target = target;
   }

   @Override
   public void save() {
      System.out.println("開始事務...");

      target.save();        //執行目標對象的方法

      System.out.println("提交事務...");
   }

}

   public static void main(String[] args) {
      //目標對象
      IUserDao target = new UserDao();

      // 代理
      IUserDao proxy = new UserDaoProxy(target);
      proxy.save();  //執行的是代理的方法
   }

總結靜態代理：

可以做到在不修改目標對象的功能前提下，對目標對象功能擴展。
缺點：
- 因爲代理對象，需要與目標對象實現一樣的接口。所以會有很多代理類，類太多
- 一旦接口增加方法，目標對象與代理對象都要維護

解決：
代理工廠？可以使用動態代理

動態代理

代理對象，不需要實現接口；
代理對象的生成，是利用JDK API，動態的在內存中構建代理對象(需要我們指定創建代理對象/目標對象實現的接口的類型；);
動態代理， JDK代理，接口代理；

// 接口
public interface IUserDao {

   void save();

}

/**
 * 目標對象
 */
public class UserDao implements IUserDao{

   @Override
   public void save() {
      System.out.println("-----已經保存數據------");
   }

}

/**
 * 給所有的dao創建代理對象【動態代理】
 * 代理對象不需要實現接口
 */
public class ProxyFactory {

   // 維護一個目標對象
   private Object target;
   public ProxyFactory(Object target){
      this.target = target;
   }

   // 給目標對象，生成代理對象（通過工廠對傳過來的目標對象加工）
   // 當目標對象有多個實現方法的時候可以在執行invoke的時候判斷判斷方法名
   public Object getProxyInstance() {
      return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args)
                      throws Throwable {
                   System.out.println("開啓事務");

                   // 執行目標對象方法
                   Object returnValue = method.invoke(target, args);

                   System.out.println("提交事務");
                   return returnValue;
                }
            });
   }
}

   public static void main(String[] args) {
      // 目標對象
      IUserDao target = new UserDao();
      // 原始的類型【class cn.itcast.b_dynamic.UserDao】
      System.out.println(target.getClass());

      // 給目標對象，創建代理對象
      IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
      // class $Proxy0  內存中動態生成的代理對象
      System.out.println(proxy.getClass());

      // 執行方法【代理對象】
      proxy.save();
   }

動態代理總結：
代理對象不需要實現接口，但是目標對象一定要實現接口；否則不能用動態代理！ (class $Proxy0 implements IuserDao)

思考：
有一個目標對象，想要功能擴展，但目標對象沒有實現接口，怎樣功能擴展？
Class UserDao{}
// 子類的方式
Class subclass extends UserDao{}
以子類的方式實現(cglib代理)

Cglib代理

Cglib代理，也叫做子類代理。在內存中構建一個子類對象從而實現對目標對象功能的擴展。

JDK的動態代理有一個限制，就是使用動態代理的對象必須實現一個或多個接口。如果想代理沒有實現接口的類，就可以使用CGLIB實現
CGLIB是一個強大的高性能的代碼生成包，它可以在運行期擴展Java類與實現Java接口。它廣泛的被許多AOP的框架使用，例如Spring AOP和dynaop，爲他們提供方法的interception（攔截）
CGLIB包的底層是通過使用一個小而快的字節碼處理框架ASM，來轉換字節碼並生成新的類。不鼓勵直接使用ASM，因爲它要求你必須對JVM內部結構包括class文件的格式和指令集都很熟悉

Cglib子類代理：

需要引入cglib – jar文件，但是spring的核心包中已經包括了cglib功能，所以直接引入spring-core-3.2.5.jar即可。
引入功能包後，就可以在內存中動態構建子類
代理的類不能爲final，否則報錯。
目標對象的方法如果爲final/static, 那麼就不會被攔截，即不會執行目標對象額外的業務方法



/**
 * 目標對象
 */
public class UserDao {

   public void save() {
      System.out.println("-----已經保存數據------");
   }

}

import java.lang.reflect.Method;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

/**
 * Cglib子類代理工廠
 * (對UserDao 在內存中動態構建一個子類對象)
 */
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);

      System.out.println("提交事務.....");

      return returnValue;
   }

}

   public static void main(String[] args) {
      // 目標對象
      UserDao target = new UserDao();
      // class cn.itcast.c_cglib.UserDao
      System.out.println(target.getClass());

      // 代理對象
      UserDao proxy = (UserDao) new ProxyFactory(target).getProxyInstance();
      // UserDao的子類：class cn.itcast.c_cglib.UserDao$$EnhancerByCGLIB$$25d4aeab
      System.out.println(proxy.getClass());

      // 執行代理對象的方法
      proxy.save();
   }

在Spring的AOP編程中，如果加入容器的目標對象有實現接口，用JDK代理；如果目標對象沒有實現接口，用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);   ////..【關注點代碼】

                   }
   }

關注點代碼，就是指重複執行的代碼。

// 接口
public interface IUserDao {
   void save();
}

/**
 * 目標對象
 */
@Component   // 加入ioc容器
public class UserDao implements IUserDao{
   @Override
   public void save() {
      System.out.println("-----核心業務保存------");
   } 
}

/**
 * 代理工廠
 */
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.commite(); //執行重複代碼
                   return returnValue;
                }
            });
   }
}

bean.xml
<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="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">

   <!-- 開啓註解掃描 -->
   <context:component-scan base-package="cn.itcast.d_myaop1"></context:component-scan>

   <!-- 調用工廠方法，返回UserDao代理後的對象 -->
   <bean id="userDao_proxy" class="cn.itcast.d_myaop1.ProxyFactory" factory-method="getProxyInstance">
      <constructor-arg index="0" ref="userDao"></constructor-arg>
      <constructor-arg index="1" ref="aop"></constructor-arg>
   </bean>
</beans>

 public class App {

   ApplicationContext ac =
      new ClassPathXmlApplicationContext("cn/itcast/d_myaop1/bean.xml");

   @Test
   public void testApp() {
      IUserDao userDao = (IUserDao) ac.getBean("userDao_proxy");
      System.out.println(userDao.getClass());
      userDao.save();
   }
}

代理模式、實現AOP編程

代理模式

概述

靜態代理

動態代理

Cglib代理

手動實現AOP編程

前端使用 Konva 實現可視化設計器（13）- 折線 - 最優路徑應用【思路篇】

線程鎖技術

java io

Java傳統線程創建方式和互斥

代理模式、實現AOP編程

Java線程基礎

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結