少妇愉情理伦片,国产人妻,婷婷97狠狠成人网站

一> 代理模式

概述

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

靜態(tài)代理

靜態(tài)代理:
1）代理對象，要實現(xiàn)與目標對象一樣的接口；
2）舉例:
- 保存用戶(模擬)
  - Dao : 直接保存
  - DaoProxy : 給保存方法添加事務(wù)處理
總結(jié)靜態(tài)代理：
1）可以做到在不修改目標對象的功能前提下，對目標對象功能擴展
2）缺點 (解決：代理工廠, 可以使用動態(tài)代理)
- 因為代理對象，需要與目標對象實現(xiàn)一樣的接口。所以會有很多代理類，類太多
- 一旦接口增加方法，目標對象與代理對象都要維護

動態(tài)代理

動態(tài)代理 :
1）代理對象，不需要實現(xiàn)接口；
2）代理對象的生成，是利用JDKAPI，動態(tài)的在內(nèi)存中構(gòu)建代理對象(需要我們指定創(chuàng)建代理對象/目標對象實現(xiàn)的接口的類型)
1. 動態(tài)代理，JDK代理，接口代理；
JDK中生成代理對象的API：

|-- Proxy
    static Object newProxyInstance(
ClassLoader loader,       指定當前目標對象使用類加載器
 Class<?>[] interfaces,     目標對象實現(xiàn)的接口的類型
InvocationHandler h       事件處理器
)

動態(tài)代理總結(jié) : 代理對象不需要實現(xiàn)接口，但是目標對象一定要實現(xiàn)接口；否則不能用動態(tài)代理！(class $Proxy0 implements IuserDao)
思考：有一個目標對象，想要功能擴展，但目標對象沒有實現(xiàn)接口，怎樣功能擴展？

    Class  UserDao{}
    // 子類的方式
    Class subclass  extends  UserDao{}
    
    以子類的方式實現(xiàn)(cglib代理)

動態(tài)代理的基本代碼 :
- 動態(tài)代理類 :

// 維護一個目標對象
    private Object target;
    public ProxyFactory(Object target){
        this.target = target;
    }
    // 給目標對象，生成代理對象  
    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("開啟事務(wù)");
                        
                        // 執(zhí)行目標對象方法
                        Object returnValue = method.invoke(target, args);
                        
                        System.out.println("提交事務(wù)");
                        return returnValue;
                    }
                });
    }

- Dao類 : (實現(xiàn)接口類)

@Override
    public void save() {
        System.out.println("-----已經(jīng)保存數(shù)據(jù)！！！------");
    }

- 實用Java類 :

public static void main(String[] args) {
        // 目標對象
        IUserDao target = new UserDao();
        // 【原始的類型 class cn.itcast.b_dynamic.UserDao】
        System.out.println(target.getClass());
        
        // 給目標對象，創(chuàng)建代理對象
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
        // class $Proxy0   內(nèi)存中動態(tài)生成的代理對象
        System.out.println(proxy.getClass());
        
        // 執(zhí)行方法   【代理對象】
        proxy.save();
    }

Cglib代理

概述:
- Cglib代理，也叫做子類代理。在內(nèi)存中構(gòu)建一個子類對象從而實現(xiàn)對目標對象功能的擴展
- JDK的動態(tài)代理有一個限制，就是使用動態(tài)代理的對象必須實現(xiàn)一個或多個接口。如果想代理沒有實現(xiàn)接口的類，就可以使用CGLIB實現(xiàn)。
- CGLIB是一個強大的高性能的代碼生成包，它可以在運行期擴展Java類與實現(xiàn)Java接口。它廣泛的被許多AOP的框架使用，例如Spring AOP和dynaop，為他們提供方法的interception (攔截)
- CGLIB包的底層是通過使用一個小而快的字節(jié)碼處理框架ASM，來轉(zhuǎn)換字節(jié)碼并生成新的類。不鼓勵直接使用ASM，因為它要求你必須對JVM內(nèi)部結(jié)構(gòu)包括class文件的格式和指令集都很熟悉
Cglib子類代理：
1. 需要引入cglib – jar文件，但是spring的核心包中已經(jīng)包括了cglib功能，所以直接引入 spring-core-3.2.5.jar 即可
  2）引入功能包后，就可以在內(nèi)存中動態(tài)構(gòu)建子類
  3）代理的類不能為final，否則報錯
  4）目標對象的方法如果為final/static, 那么就不會被攔截，即不會執(zhí)行目標對象額外的業(yè)務(wù)方法
代碼實現(xiàn) :
- Cglib子類代理工廠 :

// 維護目標對象
    private Object target;
    public ProxyFactory(Object target){
        this.target = target;
    }
    // 給目標對象創(chuàng)建代理對象
    public Object getProxyInstance(){
        //1. 工具類
        Enhancer en = new Enhancer();
        //2. 設(shè)置父類
        en.setSuperclass(target.getClass());
        //3. 設(shè)置回調(diào)函數(shù)
        en.setCallback(this);
        //4. 創(chuàng)建子類(代理對象)
        return en.create();
    }
    @Override
    public Object intercept(Object obj, Method method, Object[] args,
            MethodProxy proxy) throws Throwable {
        
        System.out.println("開始事務(wù).....");
        
        // 執(zhí)行目標對象的方法
        Object returnValue = method.invoke(target, args);
        
        System.out.println("提交事務(wù).....");
        
        return returnValue;
    }

- App類 :

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());
        
        // 執(zhí)行代理對象的方法
        proxy.save();
    }

- 目標對象 :

public void save() {
        System.out.println("-----已經(jīng)保存數(shù)據(jù)！！！------");
    }

二> 手動實現(xiàn)AOP編程

AOP 面向切面的編程 : AOP可以實現(xiàn)“業(yè)務(wù)代碼”與“關(guān)注點代碼”分離

// 保存一個用戶
public void add(User user) { 
        Session session = null; 
        Transaction trans = null; 
        try { 
            session = HibernateSessionFactoryUtils.getSession();   // 【關(guān)注點代碼】
            trans = session.beginTransaction();    // 【關(guān)注點代碼】
            session.save(user);     // 核心業(yè)務(wù)代碼
            trans.commit();     //…【關(guān)注點代碼】
        } catch (Exception e) {     
            e.printStackTrace(); 
            if(trans != null){ 
                trans.rollback();   //..【關(guān)注點代碼】
            } 
        } finally{ 
            HibernateSessionFactoryUtils.closeSession(session);   ////..【關(guān)注點代碼】
        } 
   }

分析總結(jié)：
- 關(guān)注點代碼，就是指重復(fù)執(zhí)行的代碼。
- 業(yè)務(wù)代碼與關(guān)注點代碼分離，好處？
  - 注點代碼寫一次即可；
  - 開發(fā)者只需要關(guān)注核心業(yè)務(wù)；
  - 運行時期，執(zhí)行核心業(yè)務(wù)代碼時候動態(tài)植入關(guān)注點代碼 (代理)
如何分離？過程式/對象式/代理模式分離
在Spring的AOP編程中 :
- 如果加入容器的目標對象有實現(xiàn)接口，用JDK代理
- 如果目標對象沒有實現(xiàn)接口，用Cglib代理

AOP編程

Aop概述：

Aop(aspect object programming) : 面向切面編程
功能：讓關(guān)注點代碼與業(yè)務(wù)代碼分離！
關(guān)注點 : 重復(fù)代碼就叫做關(guān)注點；
切面: 關(guān)注點形成的類，就叫切面(類)！
面向切面編程，就是指對很多功能都有的重復(fù)的代碼抽取，再在運行的時候網(wǎng)業(yè)務(wù)方法上動態(tài)植入“切面類代碼”。
切入點，
執(zhí)行目標對象方法，動態(tài)植入切面代碼。
可以通過切入點表達式，指定攔截哪些類的哪些方法；給指定的類在運行的時候植入切面類代碼。

注解方式實現(xiàn)AOP編程

步驟：
1）先引入aop相關(guān)jar文件（aspectj : aop優(yōu)秀組件-> 最早提出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名稱空間
3）開啟aop注解
4）使用注解
- @Aspect : 指定一個類為切面類
- @Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))") : 指定切入點表達式
- @Before("pointCut_()") : 前置通知 : 目標方法之前執(zhí)行
- @After("pointCut_()") : 后置通知 : 目標方法之后執(zhí)行(始終執(zhí)行)
- @AfterReturning("pointCut_()") : 返回后通知 : 執(zhí)行方法結(jié)束前執(zhí)行 (異常不執(zhí)行)
- @AfterThrowing("pointCut_()") : 異常通知 : 出現(xiàn)異常時候執(zhí)行
- @Around("pointCut_()") : 環(huán)繞通知 : 環(huán)繞目標方法執(zhí)行
代碼 :
1. IUserDao.java : 接口

public interface IUserDao {
              void save();
}

2. UserDao.java : 目標對象

@Component   // 加入容器
public class UserDao implements IUserDao{
    @Override
    public void save() {
        System.out.println("-----核心業(yè)務(wù)：保存！！！------"); 
    }
}

3. Aop.java : 切面類

@Component
@Aspect  // 指定當前類為切面類
public class Aop {
    // 指定切入點表單式： 攔截哪些方法； 即為哪些類生成代理對象
    @Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))")
    public void pointCut_(){
    }
    // 前置通知 : 在執(zhí)行目標方法之前執(zhí)行
    @Before("pointCut_()")
    public void begin(){
        System.out.println("開始事務(wù)/異常");
    }
    // 后置/最終通知：在執(zhí)行目標方法之后執(zhí)行  【無論是否出現(xiàn)異常最終都會執(zhí)行】
    @After("pointCut_()")
    public void after(){
        System.out.println("提交事務(wù)/關(guān)閉");
    }
    // 返回后通知： 在調(diào)用目標方法結(jié)束后執(zhí)行 【出現(xiàn)異常不執(zhí)行】
    @AfterReturning("pointCut_()")
    public void afterReturning() {
        System.out.println("afterReturning()");
    }
    // 異常通知： 當目標方法執(zhí)行異常時候執(zhí)行此關(guān)注點代碼
    @AfterThrowing("pointCut_()")
    public void afterThrowing(){
        System.out.println("afterThrowing()");
    }
    // 環(huán)繞通知：環(huán)繞目標方式執(zhí)行
    @Around("pointCut_()")
    public void around(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("環(huán)繞前....");
        pjp.proceed();  // 執(zhí)行目標方法
        System.out.println("環(huán)繞后....");
    }
}

4. bean.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">
    <!-- 開啟注解掃描 -->
    <context:component-scan base-package="cn.itcast.e_aop_anno"></context:component-scan>
    <!-- 開啟aop注解方式 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

5.App.java :

public class App {
            ApplicationContext ac = 
        new ClassPathXmlApplicationContext("cn/itcast/e_aop_anno/bean.xml");
            // 目標對象有實現(xiàn)接口，spring會自動選擇“JDK代理”
            @Test
            public void testApp() {
                  IUserDao userDao = (IUserDao) ac.getBean("userDao");
                  System.out.println(userDao.getClass());
                  userDao.save();
            }
            // 目標對象沒有實現(xiàn)接口， spring會用“cglib代理”
            @Test
            public void testCglib() {
                  OrderDao orderDao = (OrderDao) ac.getBean("orderDao");
                  System.out.println(orderDao.getClass());
                  orderDao.save();
            }
}

XML方式實現(xiàn)AOP編程

Xml實現(xiàn)aop編程：
1）引入jar文件 (aop 相關(guān)jar，4個)
2）引入aop名稱空間
3）aop 配置
- 配置切面類（重復(fù)執(zhí)行代碼形成的類）
- aop配置 : 攔截哪些方法 / 攔截到方法后應(yīng)用通知代碼
配置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">
    
    <!-- dao 實例 -->
    <bean id="userDao" class="cn.itcast.f_aop_xml.UserDao"></bean>
    <bean id="orderDao" class="cn.itcast.f_aop_xml.OrderDao"></bean>
    
    <!-- 切面類 -->
    <bean id="aop" class="cn.itcast.f_aop_xml.Aop"></bean>
    
    <!-- Aop配置 -->
    <aop:config>
        <!-- 定義一個切入點表達式： 攔截哪些方法 -->
        <aop:pointcut expression="execution(* cn.itcast.f_aop_xml.*.*(..))" id="pt"/>
        <!-- 切面 -->
        <aop:aspect ref="aop">
            <!-- 環(huán)繞通知 -->
            <aop:around method="around" pointcut-ref="pt"/>
            <!-- 前置通知： 在目標方法調(diào)用前執(zhí)行 -->
            <aop:before method="begin" pointcut-ref="pt"/>
            <!-- 后置通知： -->
            <aop:after method="after" pointcut-ref="pt"/>
            <!-- 返回后通知 -->
            <aop:after-returning method="afterReturning" pointcut-ref="pt"/>
            <!-- 異常通知 -->
            <aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>
            
        </aop:aspect>
    </aop:config>
</beans>

切入點表達式

切入點表達式 : 可以對指定的“方法”進行攔截；從而給指定的方法所在的類生層代理對象
代碼示例 :

<?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">
    
    <!-- dao 實例 -->
    <bean id="userDao" class="cn.itcast.g_pointcut.UserDao"></bean>
    <bean id="orderDao" class="cn.itcast.g_pointcut.OrderDao"></bean>
    
    <!-- 切面類 -->
    <bean id="aop" class="cn.itcast.g_pointcut.Aop"></bean>
    
    <!-- Aop配置 -->
    <aop:config>
        
        <!-- 定義一個切入點表達式： 攔截哪些方法 -->
        <!--<aop:pointcut expression="execution(* cn.itcast.g_pointcut.*.*(..))" id="pt"/>-->
        
        <!-- 【攔截所有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個且關(guān)系的，沒有意義 -->
        <!--<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"/>-->
        <aop:pointcut expression=" not execution(* cn.itcast.g_pointcut.OrderDao.save())" id="pt"/>
        
        <!-- 切面 -->
        <aop:aspect ref="aop">
            <!-- 環(huán)繞通知 -->
            <aop:around method="around" pointcut-ref="pt"/>
        </aop:aspect>
    </aop:config>
</beans>

Spring對jdbc支持

使用步驟：
1）引入jar文件 :
- spring-jdbc-3.2.5.RELEASE.jar
- spring-tx-3.2.5.RELEASE.jar
  2）優(yōu)化
代碼示例 :
1. XML配置文件 : bean.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">
    
    <!-- 1. 數(shù)據(jù)源對象: C3P0連接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
        <property name="initialPoolSize" value="3"></property>
        <property name="maxPoolSize" value="10"></property>
        <property name="maxStatements" value="100"></property>
        <property name="acquireIncrement" value="2"></property>
    </bean>
    
    <!-- 2. 創(chuàng)建JdbcTemplate對象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <!-- dao 實例 -->
    <bean id="userDao" class="cn.itcast.h_jdbc.UserDao">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
    </bean>
</beans>

Dao類 : UserDao

public class UserDao {
    // IOC容器注入
//  private DataSource dataSource;
//  public void setDataSource(DataSource dataSource) {
//      this.dataSource = dataSource;
//  }
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    public void save() {
        String sql = "insert into t_dept(deptName) values('test');";
        jdbcTemplate.update(sql);
    }
    public Dept findById(int id) {
        String sql = "select * from t_dept where deptId=?";
        List<Dept> list = jdbcTemplate.query(sql,new MyResult(), id);
        return (list!=null && list.size()>0) ? list.get(0) : null;
    }
    public List<Dept> getAll() {
        String sql = "select * from t_dept";
        List<Dept> list = jdbcTemplate.query(sql, new MyResult());
        return list;
    }
    class MyResult implements RowMapper<Dept>{

        // 如何封裝一行記錄
        @Override
        public Dept mapRow(ResultSet rs, int index) throws SQLException {
            Dept dept = new Dept();
            dept.setDeptId(rs.getInt("deptId"));
            dept.setDeptName(rs.getString("deptName"));
            return dept;
        }
        
    }
}

使用類 : App

public class App {
    // 容器對象
    ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/h_jdbc/bean.xml");
    @Test
    public void testApp() throws Exception {
        UserDao ud = (UserDao) ac.getBean("userDao");
//      ud.save();
        System.out.println(ud.findById(9));
        System.out.println(ud.getAll());
    }
}

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Spring框架核心(2) : 代理模式 & AOP編程 & Spring對jdbc支持

Spring框架核心(2) : 代理模式 & AOP編程 & Spring對jdbc支持

一> 代理模式

二> 手動實現(xiàn)AOP編程

AOP編程

Spring對jdbc支持

推薦閱讀更多精彩內(nèi)容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Spring框架核心(2) : 代理模式 & AOP編程 & Spring對jdbc支持

一> 代理模式

二> 手動實現(xiàn)AOP編程

AOP編程

Spring對jdbc支持

推薦閱讀更多精彩內(nèi)容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频