（转）Spring使用AspectJ进行AOP的开发：注解方式

http://blog.csdn.net/yerenyuan_pku/article/details/69790950

Spring使用AspectJ进行AOP的开发：注解方式

之前我已讲过Spring使用AspectJ通过配置文件的方式来进行AOP的开发，现在就来讲怎样使用注解方式进行AOP的开发。

  • 创建一个Web项目， 引入相关的jar包。所要导入的jar包如下： 
  • 引入Spring的配置文件。主要引入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: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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

</beans>
  • 编写目标类。 
    在Web项目的src目录下创建一个cn.itcast.aop包，并在该包下编写一个Book类： 
    public class Book {

    public void add() {
        System.out.println("book add.................");
    }

}
  • 编写切面类。 
    再在cn.itcast.aop包下编写一个MyBook增强类： 
    public class MyBook {

    public void before1() {
        System.out.println("before........");
    }

}
  • 在增强的类上面使用@Aspect注解 
    @Aspect
public class MyBook {

    public void before1() {
        System.out.println("before........");
    }

}
  • 在增强类的方法里面，使用注解配置通知类型： 
    @Aspect
public class MyBook {

    // 前置通知
    // *：方法的访问修饰符，也可写为execution(public void cn.itcast.aop.Book.*(..))，但一般都不会用
    @Before("execution(* cn.itcast.aop.Book.*(..))")
    public void before1() {
        System.out.println("before........");
    }

}
    • 1

    AspectJ的AOP的注解：

    • @Aspect：定义切面类的注解
    • @Before：前置通知，相当于BeforeAdvice
    • @AfterReturning：后置通知，相当于AfterReturningAdvice
    • @Around：环绕通知，相当于MethodInterceptor
    • @AfterThrowing：抛出通知，相当于ThrowAdvice
    • @After：最终final通知，不管是否异常，该通知都会执行
    • @Pointcut：定义切入点的注解
  • 开启AspectJ的注解 
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
  • 创建Book类和MyBook类的两个对象(使用配置文件) 
    <bean id="book" class="cn.itcast.aop.Book"></bean>
<bean id="myBook" class="cn.itcast.aop.MyBook"></bean>
  • 最后在cn.itcast.aop包下编写一个TestDemo单元测试类 
    public class TestDemo {

    @Test
    public void testBook() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        Book book = (Book) context.getBean("book");
        book.add();
    }
}
    • 1

    测试即可。

Spring的JDBC模板

Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。它针对JavaEE三层中的每一层都提供了不同的解决技术，在dao层，Spring提供了JDBC模板的技术，可对数据库进行CRUD操作。Spring提供了很多持久层技术的模板类简化了编程，如下图： 

我再次加以说明：Spring框架对不同的持久层技术做了封装，如对传统的JDBC使用JdbcTemplate进行了封装，对Hibernate框架使用HibernateTemplate进行了封装。JdbcTemplate对JDBC进行了简单封装，使用类似于dbutils，但是使用并没有dbutils方便，只是提供了一种实现的方式而已。下面来演示使用JdbcTemplate模板类实现CRUD操作。

使用JdbcTemplate模板类实现CRUD操作

首先创建数据库和表，如下：

create database spring_lee;
use spring_lee;

DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
  `username` varchar(100) DEFAULT NULL,
  `password` varchar(100) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  • 1

使用JdbcTemplate模板类还须导入jar包，先引入JdbcTemplate的jar包： 

但我们要知道spring-jdbc-4.2.4.RELEASE.jar包才是最主要的。除此之外还须导入MySQL数据库驱动的jar包。

添加操作

在src目录下创建一个cn.itcast.jdbcTemplate包，并在该包下编写一个JdbcTemplateDemo1单元测试类。现在要编写一个add方法来测试添加操作。

public class JdbcTemplateDemo1 {

    // 1.添加操作
    @Test
    public void add() {
        // 1.设置数据库相关信息(JDBC模板依赖连接池获得数据库连接，所以必须先构造连接池)
        DriverManagerDataSource dataSource = new DriverManagerDataSource(); // 数据源
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///spring_lee");
        dataSource.setUsername("root");
        dataSource.setPassword("yezi");

        // 2.做添加的操作
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        String sql = "insert into user values(?,?)";
        int rows = jdbcTemplate.update(sql, "liayun", "lee");
        System.out.println(rows);
    }

}
  • 1

注意：JDBC模板依赖连接池获得数据库连接，所以必须先构造连接池，然后再创建JdbcTemplate模板类对象。而且还须用到JdbcTemplate模板类的update方法： 
 
这个方法中有两个参数：

  • 第一个参数是sql语句。
  • 第二个参数是传递的参数值，Object类型的可变参数。

修改操作

现在要在单元测试类中编写一个update方法来测试修改操作。

public class JdbcTemplateDemo1 {

    // 2.修改操作
    @Test
    public void update() {
        // 1.设置数据库相关信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource(); // 数据源
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///spring_lee");
        dataSource.setUsername("root");
        dataSource.setPassword("yezi");

        // 实现修改操作
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        String sql = "update user set password=? where username=?";
        int rows = jdbcTemplate.update(sql, "9999", "liayun");
        System.out.println(rows);
    }

}
  • 1

删除操作

现在要在单元测试类中编写一个delete方法来测试删除操作。

public class JdbcTemplateDemo1 {

    // 3.删除操作
    @Test
    public void delete() {
        // 1.设置数据库相关信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource(); // 数据源
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///spring_lee");
        dataSource.setUsername("root");
        dataSource.setPassword("yezi");

        // 实现删除操作
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        String sql = "delete from user where username=?";
        int rows = jdbcTemplate.update(sql, "liayun");
        System.out.println(rows);
    }

}
  • 1

查询操作

查询表中的记录数

现在要在单元测试类中编写一个testCount方法来测试查询表中记录数的操作。

public class JdbcTemplateDemo1 {

    // 查询表记录数
    @Test
    public void testCount() {
        // 1.设置数据库相关信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource(); // 数据源
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///spring_lee");
        dataSource.setUsername("root");
        dataSource.setPassword("yezi");

        // 2.创建JdbcTemplate模板类的对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        // 3.sql语句
        String sql = "select count(*) from user";
        // 4.调用JdbcTemplate模板类里面的方法
        // 返回int类型
        int count = jdbcTemplate.queryForObject(sql, Integer.class);
        System.out.println(count);
    }

}
  • 1

在查询表中记录数的操作时，用到了JdbcTemplate模板类里面的queryForObject方法，如下： 
 
这个方法中有两个参数：

  • 第一个参数：sql语句
  • 第二个参数：返回类型的class

查询返回对象

使用JdbcTemplate模板类进行查询操作的时候，还是比较麻烦的。前面我也说过JdbcTemplate对JDBC进行了简单封装，使用类似于dbutils，但是使用并没有dbutils方便，只是提供了一种实现的方式而已。我是为何这么说呢？因为在dbutils里面帮我们编写好了一些实现类，使用这些实现类可以封装结果，这些实现类都实现了接口ResultSetHandler；使用JdbcTemplate模板类进行查询操作返回数据结果的时候，虽然在JdbcTemplate模板类中有个接口，但是并没有提供实现类，故还需要自己编写实现类来封装结果。 
好了，接下来复习一下编写JDBC最原始的代码做查询操作，基本功不要忘记了啊！ 
首先在cn.itcast.jdbcTemplate包下编写一个User类。

public class User {

    private String username;
    private String password;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "User [username=" + username + ", password=" + password + "]";
    }

}
  • 1

然后再在该包下编写一个JdbcTemplateDemo2单元测试类，编写JDBC最原始的代码做查询操作。

public class JdbcTemplateDemo2 {

    // jdbc最原始的代码做查询操作
    @Test
    public void testJDBC() {
        Connection conn = null;
        PreparedStatement psmt = null;
        ResultSet rs = null;

        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection("jdbc:mysql:///spring_lee", "root", "yezi");
            String sql = "select * from user where username=?";
            // 对sql进行预编译操作
            psmt = conn.prepareStatement(sql);
            psmt.setString(1, "mary");
            // 执行sql
            rs = psmt.executeQuery();
            // 遍历结果
            while (rs.next()) {
                String username = rs.getString("username");
                String password = rs.getString("password");

                User user = new User();
                user.setUsername(username);
                user.setPassword(password);
                System.out.println(user);
            }
        } catch (Exception e) {

        } finally {
            try {
                rs.close();
                psmt.close();
                conn.close();
            } catch (Exception e2) {

            }
        }
    }       

}
  • 1

接下来，就来讲如何使用JdbcTemplate模板类进行查询操作并返回一个User类的对象。其中就要用到JdbcTemplate模板类里面的queryForObject方法： 

这个方法有3个参数：

  • 第一个参数：sql语句
  • 第二个参数：RowMapper接口 
    1. 之前使用dbutils进行查询时，返回结果有ResultSetHandler接口，但是在dbutils里面有其对应的实现类。
    2. 使用JdbcTemplate模板类的时候，虽然提供了RowMapper接口，但是这个接口没有实现类，需要自己进行实现，然后进行数据封装。
  • 第三个参数：可变参数

现在要在JdbcTemplateDemo2单元测试类中编写一个testObject方法来测试查询时返回一个User类对象的操作。

public class JdbcTemplateDemo2 {

    // 1.查询返回对象
    @Test
    public void testObject() {

        // 1.设置数据库相关信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource(); // 数据源
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///spring_lee");
        dataSource.setUsername("root");
        dataSource.setPassword("yezi");

        // 2.创建JdbcTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        // 3.sql语句
        String sql = "select * from user where username=?";

        // 4.调用方法执行
        // 第二个参数是接口，RowMapper，要自己创建一个类实现这个接口，在里面进行封装
        User user = jdbcTemplate.queryForObject(sql, new MyRowMapper(), "mary");
        System.out.println(user);

    }

}
  • 1

注意，还要编写RowMapper接口的一个实现类。在以上JdbcTemplateDemo2.java源代码文件中编写RowMapper接口的一个MyRowMapper实现类。

// T：表示要将数据封装到哪个类的对象中
class MyRowMapper implements RowMapper<User> {

    // 实现接口里面的方法，在方法中实现数据封装
    // 第一个参数：返回的结果集，第二个参数是当前的行数(即第几行)
    @Override
    public User mapRow(ResultSet rs, int rows) throws SQLException {
        // 从结果集得到数据
        String username = rs.getString("username");
        String password = rs.getString("password");

        // 封装到对象里面
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);
        return user;
    }

}
  • 1

查询返回List集合

现在要在JdbcTemplateDemo2单元测试类中编写一个testList方法来测试查询时返回List集合的操作。

public class JdbcTemplateDemo2 {

    // 2.返回List集合
    @Test
    public void testList() {

        // 1.设置数据库相关信息
        DriverManagerDataSource dataSource = new DriverManagerDataSource(); // 数据源
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///spring_lee");
        dataSource.setUsername("root");
        dataSource.setPassword("yezi");

        // 2.查询操作
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        String sql = "select * from user";

        List<User> list = jdbcTemplate.query(sql, new MyRowMapper());
        System.out.println(list);

    }

}

在进行查询并返回List集合的操作时，须用到JdbcTemplate模板类里面的query方法： 

或 

Spring配置连接池

在实际开发中，一般都会用Spring配置C3P0连接池，所以下面我就来重点介绍在Spring中如何配置C3P0连接池。 
首先引入Spring的配置文件，主要是引入约束：

<?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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx.xsd">

</beans>

接着导入Spring的基本jar包，除此之外，还要导入C3P0的jar包： 

试想要是以前在Web项目中配置C3P0连接池，势必会写这样的代码：

ComboPooledDataSource dataSource = new ComboPooledDataSource();
dataSource.setDriverClass(driverClass);
dataSource.setJdbcUrl(jdbcUrl);
dataSource.setUser(user);
dataSource.setPassword(password);

而现在我们就可以在Spring配置文件(bean2.xml)中配置C3P0连接池了，即在Spring配置文件中添加如下配置：

<!-- 配置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:///spring_lee"></property>
    <property name="user" value="root"></property>
    <property name="password" value="yezi"></property>
</bean>

现在举例来演示如何在Spring中配置C3P0连接池了。我的思路是这样的：创建一个UserService类和一个UserDao类，然后在UserService类里面调用UserDao类的方法，在UserDao类中使用JdbcTemplate模板类进行数据库CRUD操作，并且用上C3P0连接池。 
先在src目录下创建一个cn.itcast.c3p0包，并在该包下编写一个UserDao类。

public class UserDao {

    // 在Dao里面要得到JdbcTemplate对象
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    // 添加操作，使用JdbcTemplate模板来实现添加
    public void add() {
        String sql = "insert into user values(?,?)";
        jdbcTemplate.update(sql, "李阿昀", "lee");
    }
}

再在该包下编写一个UserService类，并在UserService类里面调用UserDao类的add方法。

public class UserService {

    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add() {
        userDao.add();
    }
}

那么Spring核心配置文件就应该像下面这样配置：

<!-- 配置service和dao以及它们的注入 -->
<bean id="userService" class="cn.itcast.c3p0.UserService">
    <property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="cn.itcast.c3p0.UserDao">
    <property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>

<!-- 配置JdbcTemplate模板类的对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!-- 注入dataSource，因为在其源代码中dataSource属性有其对应的set方法，故可直接注入 -->
    <property name="dataSource" ref="dataSource"></property>
</bean>

从上面的配置可看出：UserDao中注入了JdbcTemplate对象，JdbcTemplate对象里面又注入了dataSource。 
最后再在该包下编写一个TestDemo单元测试类。

public class TestDemo {

    @Test
    public void testBook() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}
时间： 2024-11-10 11:22:45

（转）Spring使用AspectJ进行AOP的开发：注解方式的相关文章

[Spring框架]Spring AOP基础入门总结二:Spring基于AspectJ的AOP的开发.

前言: 在上一篇中: [Spring框架]Spring AOP基础入门总结一. 中 我们已经知道了一个Spring AOP程序是如何开发的, 在这里呢我们将基于AspectJ来进行AOP 的总结和学习. 一, AspectJ的概述: AspectJ是一个面向切面的框架,它扩展了Java语言.AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件. Spring为了简化自身的AOP的开发,将AspectJ拿过来作为Spring自身一个AOP的开发.

Spring的AspectJ的AOP，基于注解(9.1)重点掌握

什么是AspectJ AspectJ是一个面向切面的框架,它扩展了Java语言.AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件.AspectJ是一个基于Java语言的AOP框架Spring2.0以后新增了对AspectJ切点表达式支持@AspectJ 是AspectJ1.5新增功能,通过JDK5注解技术,允许直接在Bean类中定义切面新版本Spring框架,建议使用AspectJ方式来开发AOP AspectJ表达式: 语法:executi

Spring声明式事务管理（基于注解方式实现）

----------------------siwuxie095 Spring 声明式事务管理(基于注解方式实现) 以转账为例 1.导入相关 jar 包(共 10 个包) (1)导入核心 jar 包和日志相关的 jar 包 (2)导入 JdbcTemplate 的 jar 包 (3)导入 MySQL 的 JDBC 驱动包 mysql-connector-java 下载链接: https://dev.mysql.com/downloads/connector/j/ (4)导入 AOP 的 jar

Spring第七弹—依赖注入之注解方式注入及编码解析@Resource原理

    注入依赖对象可以采用手工装配或自动装配,在实际应用中建议使用手工装配,因为自动装配会产生未知情况,开发人员无法预见最终的装配结果. 手工装配依赖对象  手工装配依赖对象,在这种方式中又有两种编程方式 在xml配置文件中,通过在bean节点下配置,上边博客已经讲解,再次不在缀余. 在java代码中使用@Autowired或@Resource注解方式进行装配.但我们需要在xml配置文件中配置以下信息: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 <be

spring与hibernate整合配置基于Annotation注解方式管理实务

1.配置数据源 数据库连接基本信息存放到properties文件中,因此先加载properties文件 1 <!-- jdbc连接信息 --> 2 <context:property-placeholder 3 location="classpath:io/shuqi/ssh/spring/transactionalAnnotation/jdbc.properties"/> 使用DBCP数据源配置xml如下 1 <!-- dbcp数据源配置 -->

初步学习Spring Aop使用之注解方式

前言: 这里就主要演示Spring中Aop使用注解是怎么使用,如果需要了解更多Aop相关概念,可查看相关资料的介绍 一.项目目录 [标记文件为主要文件] 二.各个文件的代码 AopServer.java [编写切点的文件,就是一些需要被修饰的业务处理] package aop; import org.springframework.stereotype.Service; @Service public class AopServer { public void add() { System.ou

spring AOP解析之注解方式详解

命名空间处理器是AopNamespaceHandler,我们可以看到这里注册了几个解析器,第一个我们知道是xml形式的解析,接下来我们看AspectJAutoProxyBeanDefinitionParser解析器

Spring MVC入门（1）——非注解方式

开发工具:Myeclipse 8.5,jdk1.6,Tomcat7.0 1.建立WebProject项目,导入Spring 3.2.3相关jar包 2.在web.xml中配置前端控制器,DispatcherServlet. <servlet> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <servlet-name>springmvc</

Spring框架学习——AOP的开发

一.AOP开发中的相关术语. ——JoinPoint(连接点):指那些可以被拦截到的点.比如增删改查方法都可以增强,这些方法就可以被称为是连接点. ——PointCut:切入点,真正被拦截的点,指对哪些连接点进行拦截的定义.JoinPoint是指方法可以增强,而切入点就是实际哪个方法进行增强或修改,这样的方法被称为切入点. ——Advice(增强/通知):方法层面的增强.指拦截到了方法后需要做的事情,也就是增强的功能部分被称为通知.分为前置(方法主体之前).后置.环绕通知. ——Introduc