java--Spring代理模式、AOP、jdbc支持 - NE_STOP

公告

代理模式

静态代理，

1） 代理对象，要实现与目标对象一样的接口；
2） 举例:保存用户(模拟)
            Dao  ,  直接保存
            DaoProxy, 给保存方法添加事务处理

App.java

public class App {

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

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

IUserDao.java

// 接口
public interface IUserDao {

    void save();
}

UserDao.java

public class UserDao implements IUserDao{

@Override
public void save() {
    System.out.println("-----已经保存数据！！！------");
}

}

UserDaoProxy.java

/**
 * 代理对象(静态代理)
 *     代理对象，要实现与目标对象一样的接口
 * @author Jie.Yuan
 *
 */
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("提交事务...");
}

}

总结静态代理：

1）可以做到在不修改目标对象的功能前提下，对目标对象功能扩展。
2）缺点：
    --》  因为代理对象，需要与目标对象实现一样的接口。所以会有很多代理类，类太多。
    --》  一旦接口增加方法，目标对象与代理对象都要维护。

解决：

代理工厂？  可以使用动态代理。

动态代理

动态代理，

1）代理对象，不需要实现接口；
2）代理对象的生成，是利用JDKAPI， 动态的在内存中构建代理对象(需要我们指定创建 代理对象/目标对象 实现的接口的类型；);
3)  动态代理， JDK代理， 接口代理；

JDK中生成代理对象的API：

|-- Proxy
    static Object newProxyInstance(
ClassLoader loader,       指定当前目标对象使用类加载器
 Class<?>[] interfaces,     目标对象实现的接口的类型
InvocationHandler h       事件处理器
)

App.java

public class App {

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();
}
}

IUserDao.java

// 接口
public interface IUserDao {

    void save();

}

ProxyFactory.java

/**
 * 给所有的dao创建代理对象【动态代理】
 * 
 * 代理对象，不需要实现接口
 * @author Jie.Yuan
 *
 */
public class ProxyFactory {

// 维护一个目标对象
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("开启事务");

                    // 执行目标对象方法
                    Object returnValue = method.invoke(target, args);

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

UserDao.java

/**
 * 目标对象
 * @author Jie.Yuan
 *
 */
public class UserDao implements IUserDao{

@Override
public void save() {
    System.out.println("-----已经保存数据！！！------");
}
}

动态代理总结：

代理对象不需要实现接口，但是目标对象一定要实现接口；否则不能用动态代理！
(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文件的格式和指令集都很熟悉。

App.java

public class 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());

    // 执行代理对象的方法
    proxy.save();
}
}

ProxyFactory.java

/**
 * Cglib子类代理工厂
 * (对UserDao 在内存中动态构建一个子类对象)
 * @author Jie.Yuan
 *
 */
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;
}
}

UserDao.java

public class UserDao {

public void save() {
    System.out.println("-----已经保存数据！！！------");
}
}

Cglib子类代理：

1) 需要引入cglib – jar文件， 但是spring的核心包中已经包括了cglib功能，所以直接引入spring-core-3.2.5.jar即可。
2）引入功能包后，就可以在内存中动态构建子类
3）代理的类不能为final， 否则报错。
4） 目标对象的方法如果为final/static, 那么就不会被拦截，即不会执行目标对象额外的业务方法。

在Spring的AOP编程中，如果加入容器的目标对象有实现接口，用JDK代理；如果目标对象没有实现接口，用Cglib代理；

AOP编程

手动实现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);   ..【关注点代码】

        } 
   }

分析总结：

关注点代码，就是指重复执行的代码。
业务代码与关注点代码分离，好处？
   -- 关注点代码写一次即可；
    -开发者只需要关注核心业务；
    -运行时期，执行核心业务代码时候动态植入关注点代码； 【代理】

如何分离？

过程式/对象式/代理模式分离

Aop.java

@Component  // 加入IOC容器  （切面）
public class Aop {

// 重复执行的代码
public void begin(){
    System.out.println("开始事务/异常");
}
public void commite(){
    System.out.println("提交事务/关闭");
}
}

App.java

    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();
    }
}

IUserDao.java

// 接口
public interface IUserDao {

    void save();

}

ProxyFactory.java

    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;
                    }
                });
    }
}

UserDao.java

@Component   // 加入容器
public class UserDao implements IUserDao{

    @Override
    public void save() {
        System.out.println("-----核心业务：保存！！！------");
    }

}

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"
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>

概述

Aop， aspect object programming 面向切面编程

功能： 让关注点代码与业务代码分离！

关注点,

重复代码就叫做关注点；

切面，

 关注点形成的类，就叫切面(类)！
 面向切面编程，就是指 对很多功能都有的重复的代码抽取，再在运行的时候网业务方法上动态植入“切面类代码”。

切入点，

执行目标对象方法，动态植入切面代码。
可以通过切入点表达式，指定拦截哪些类的哪些方法； 给指定的类在运行的时候植入切面类代码。

注解方式实现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名称空间
3） 开启aop注解

4) 使用注解

@Aspect                         指定一个类为切面类       
@Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))")  指定切入点表达式

@Before("pointCut_()")              前置通知: 目标方法之前执行
@After("pointCut_()")                   后置通知：目标方法之后执行（始终执行）
@AfterReturning("pointCut_()")          返回后通知： 执行方法结束前执行(异常不执行)
@AfterThrowing("pointCut_()")           异常通知:  出现异常时候执行

@Around(“pointCut_()”) 环绕通知：环绕目标方法执行

1. IUserDao.java

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

UserDao.java ###
/**
- 目标对象
- @author Jie.Yuan
  *
  */
  @Component // 加入容器
  public class UserDao implements IUserDao{
  
  @Override
  public void save() {
  System.out.println(“—–核心业务：保存！！！——”);
  }
  }

3. Aop.java 切面类

@Component
@Aspect  // 指定当前类为切面类
public class Aop {

    // 指定切入点表单式： 拦截哪些方法； 即为哪些类生成代理对象

    @Pointcut("execution(* cn.itcast.e_aop_anno.*.*(..))")
    public void 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("环绕后....");
    }

}

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>

App.java

public class App {

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

    // 目标对象有实现接口，spring会自动选择“JDK代理”
    @Test
    public void testApp() {
        IUserDao userDao = (IUserDao) ac.getBean("userDao");
        System.out.println(userDao.getClass());
        userDao.save();
    }

    // 目标对象没有实现接口， spring会用“cglib代理”
    @Test
    public void testCglib() {
        OrderDao orderDao = (OrderDao) ac.getBean("orderDao");
        System.out.println(orderDao.getClass());
        orderDao.save();
    }
}

XML方式实现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">

<!-- 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">
        <!-- 环绕通知 -->
        <aop:around method="around" pointcut-ref="pt"/>
        <!-- 前置通知： 在目标方法调用前执行 -->
        <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个且关系的，没有意义 -->
    <!--<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">
        <!-- 环绕通知 -->
        <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） 优化

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. 数据源对象: 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. 创建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>

UserDao.java

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;
    }

}
}

posted on 2018-07-12 15:42 NE_STOP 阅读(2) 评论(0) 编辑收藏举报来源

刷新页面返回顶部

代理模式

静态代理，

App.java

IUserDao.java

UserDao.java

UserDaoProxy.java

动态代理

App.java

IUserDao.java

ProxyFactory.java

UserDao.java

Cglib代理

App.java

ProxyFactory.java

UserDao.java

AOP编程

手动实现AOP编程

Aop.java

App.java

IUserDao.java

ProxyFactory.java

UserDao.java

bean.xml

概述

注解方式实现AOP编程

4) 使用注解

@Around(“pointCut_()”) 环绕通知： 环绕目标方法执行

1. IUserDao.java

3. Aop.java 切面类

4. bean.xml

App.java

XML方式实现AOP编程

切入点表达式

Spring对jdbc支持

bean.xml

UserDao.java

@Around(“pointCut_()”) 环绕通知：环绕目标方法执行