spring（二）之Aop、AspectJ和JdbcTemplate

刺骨的言语ヽ痛彻心扉 2021-09-30 10:36 298阅读 0赞

一、Aop【Aspect Oriented Programming】（面向切面编程）

1、概述：

通过[预编译][Link 1]方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是[OOP][]的延续，是软件开发中的一个热点，也是[Spring][]框架中的一个重要内容，是[函数式编程][Link 2]的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的[耦合度][Link 3]降低，提高程序的可重用性，同时提高了开发的效率。

优点：①各个步骤之间的良好隔离性；②源代码无关性 。

缺点：难用。你需要实现大量的接口，继承大量的类。

2、主要功能：日志记录，性能统计，安全控制，事务处理，[异常处理][Link 4]等等。

3、主要意图：将日志记录，性能统计，安全控制，事务处理，[异常处理][Link 4]等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

4、Aop实现原理：①通过代理机制实现；②接口+实现类：可以采用jdk的proxy来生成代理对象；③有接口的实现类和没接口的实现类都可以采用cglib字节码增强 来实现代理。

5、Aop 术语

①通知（Advice）：想要实现的功能，也就是上面说的 安全，事物，日志等。

②连接点（JoinPoint）：就是spring允许使用通知的地方，基本每个方法的前，后（两者都有也行），或抛出异常时都可以是连接点，spring只支持方法连接点.其他如aspectJ还可以让你在构造器或属性注入时都行。

③切入点（Pointcut）：在调用某几个方法之前，之后或者抛出异常时干点什么，那么就用切入点来定义这几个方法，让切入点来筛选连接点，选中那几个你想要的方法。

④切面（Aspect）：切面是通知和切入点的结合。（没连接点什么事情，连接点就是为了让你好理解切点，搞出来的，明白这个概念就行了。）通知说明了干什么和什么时候干（什么时候通过方法名中的before,after，around等就能知道），而切入点说明了在哪干（指定到底是哪个方法），这就是一个完整的切面定义。（什么是切面？用刀把一个西瓜分成两瓣，切开的切口就是切面；炒菜，锅与炉子共同来完成炒菜，锅与炉子就是切面。web层级设计中，web层->网关层->服务层->数据层，每一层之间也是一个切面。编程中，对象与对象之间，方法与方法之间，模块与模块之间都是一个个切面**。**）

⑤引入（introduction）：　允许我们向现有的类添加新方法属性。相当于把切面（也就是新方法属性：通知定义的）用到目标类中。

⑥目标（target）：引入中所提到的目标类，也就是要被通知的对象，也就是真正的业务逻辑，它可以在毫不知情的情况下，被咱们织入切面。而自己专注于业务本身的逻辑。

⑦代理(proxy)：它允许Spring动态生成一个新类来实现必要的接口，织入通知，并且把对这些接口的任何调用都转发到目标类。

⑧织入(weaving)：把切面应用到目标对象来创建新的代理对象的过程

6、spring用代理类包裹切面，把他们织入到Spring管理的bean中。也就是说代理类伪装成目标类，它会截取对目标类中方法的调用，让调用者对目标类的调用都先变成调用伪装类，伪装类中就先执行了切面，再把调用转发给真正的目标bean。

现在可以自己想一想，怎么搞出来这个伪装类，才不会被调用者发现（过JVM的检查，JAVA是强类型检查，哪里都要检查类型）。

（1）  实现和目标类相同的接口，我也实现和你一样的接口，反正上层都是接口级别的调用，这样我就伪装成了和目标类一样的类（实现了同一接口，咱是兄弟了），也就逃过了类型检查，到java运行期的时候，利用多态的后期绑定（所以spring采用运行时），伪装类（代理类）就变成了接口的真正实现，而他里面包裹了真实的那个目标类，最后实现具体功能的还是目标类，只不过伪装类在之前干了点事情（写日志，安全检查，事务等）。

这就好比，一个人让你办件事，每次这个时候，你弟弟就会先出来，当然他分不出来了，以为是你，你这个弟弟虽然办不了这事，但是他知道你能办，所以就答应下来了，并且收了点礼物（写日志），收完礼物了，给把事给人家办了啊，所以你弟弟又找你这个哥哥来了，最后把这是办了的还是你自己。但是你自己并不知道你弟弟已经收礼物了，你只是专心把这件事情做好。

顺着这个思路想，要是本身这个类就没实现一个接口呢，你怎么伪装我，我就压根没有机会让你搞出这个双胞胎的弟弟，那么就用第2种代理方式，创建一个目标类的子类，生个儿子，让儿子伪装我

（2）生成子类调用，这次用子类来做为伪装类，当然这样也能逃过JVM的强类型检查，我继承的吗，当然查不出来了，子类重写了目标类的所有方法，当然在这些重写的方法中，不仅实现了目标类的功能，还在这些功能之前，实现了一些其他的（写日志，安全检查，事物等）。

这次的对比就是，儿子先从爸爸那把本事都学会了，所有人都找儿子办事情，但是儿子每次办和爸爸同样的事之前，都要收点小礼物（写日志），然后才去办真正的事。当然爸爸是不知道儿子这么干的了。这里就有件事情要说，某些本事是爸爸独有的(final的)，儿子学不了，学不了就办不了这件事，办不了这个事情，自然就不能收人家礼了。

前一种兄弟模式，spring会使用JDK的java.lang.reflect.Proxy类，它允许Spring动态生成一个新类来实现必要的接口，织入通知，并且把对这些接口的任何调用都转发到目标类。

后一种父子模式，spring使用CGLIB库生成目标类的一个子类，在创建这个子类的时候，spring织入通知，并且把对这个子类的调用委托到目标类。

相比之下，还是兄弟模式好些，他能更好的实现松耦合，尤其在今天都高喊着面向接口编程的情况下，父子模式只是在没有实现接口的时候，也能织入通知，应当做一种例外。

7、cglib（增强字节码）

①没有接口，只有实现类；②采用字节码增强框架cglib，在运行时创建目标类的子类，从而对目标类进行增强。③导入架包：核心包hibernate-distribution-3.6.10.Final\\lib\\bytecode\\cglib\\cglib-2.2.jar和依赖包struts-2.3.15.3\\apps\\struts2-blank\\WEB-INF\\lib\\asm-3.3.jar

spring-core.jar已经整合上面的两个包了。

8、AOP联盟

①前置通知(Before Advice)：在目标方法执行前实施增强。 在连接点之前执行的Advice，不过除非它抛出异常，否则没有能力中断执行流。使用 `@Before` 注解使用这个Advice。

②后置通知(After Advice)：在目标方法执行后实施增强。 无论连接点是通过什么方式退出的(正常返回或者抛出异常)都会执行在结束后执行这些Advice。通过 `@After` 注解使用。

③环绕通知(Around Advice)：在目标方法执行、后前实施增强。围绕连接点执行的Advice，就你一个方法调用。这是最强大的Advice。通过 `@Around`注解使用。

④异常抛出通知(AfterThrowing Advice)：在方法抛出异常后实施增强。如果一个方法通过抛出异常来退出的话，这个Advice就会被执行。通用 `@AfterThrowing` 注解来使用。

9、AspectJ

①它是一个基于java语言的AOP框架；②兼容Java平台，可以无缝扩展。spring2.0以后新增了对切点表达式的支持。③易学易用。@AspectJ是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面。（新版本Spring建议使用AspectJ方式来开发AOP，主要用途：自定义开发）

AspectJ与  Spring Aop的区别： Spring Aop采用的动态织入，而Aspectj是静态织入。静态织入：指在编译时期就织入，即：编译出来的class文件，字节码就已经被织入了。动态织入又分静动两种，静则指织入过程只在第一次调用时执行；动则指根据代码动态运行的中间状态来决定如何操作，每次调用Target的时候都执行。

10、切点表达式

语法：execution(修饰符 返回值 包.类.方法名（参数）throws 异常)

execution(\* com.nic.\* .\*(..))

修饰符：一般省略

第一个\*代表所有的返回值类型 ：不能省略 。void 表示返回没有值 、 String 表示返回字符串  、 \*  表示 任意值

包 ： com.nic 固定包

第二个\*代表所有的类

第三个\*代表类所有方法

最后一个..代表所有的参数

11、JdbcTemplate

（1）简介：①JdbcTemplate类似于人DBUtils，用于操作Jdbc的工具类，它需要依赖于连接池，DataSource（数据源）；②JDBC（java DataBase Connectivity，java数据库连接）是一种用于执行SQL语句的java API；③ODBC（Open Database Connectivity）开放数据库连接，是微软公司开源提供的一组数据库访问的标准API（应用编程接口）（常用于SQLserver）；④DBCP（DataBase Connection Pool）数据库连接池，是java数据库连接池的一种，由Apache开发；⑤C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate,spring等。

（2）C3P0和dbcp的区别：①dbcp没有自动回收空闲连接功能， C3P0有；②两者主要是对数据连接的处理方式不同！C3P0提供最大空闲时间，DBCP提供最大连接数；③前者当连接超过最大空闲连接时间时，当前连接就会被断掉。DBCP当连接数超过最大连接数时，所有连接都会被断开；④dbcp它的原理是维护多个连接对象Connection,在web项目要连接数据库时直接使用它维护的对象进行连接，省去每次都要创建连接对象的麻烦。提高效率和减少内存使用。s3p0可以自动回收连接，dbcp需要自己手动释放资源返回。不过dbcp效率比较高。

（3）导入架包：①com.springsource.com.mchange.v2.c3p0-0.9.1.2.jar（c3p0连接池）/

com.springsource.org.apache.commons.dbcp-1.2.2.osgi.jar、com.springsource.org.apache.commons.pool-1.5.3jar(c3p0连接池和dbcp连接池选择一种导入就行）；②mysql-connector-java-5.0.8-bin.jar(mysql驱动) 、③spring-jdbc-3.2.0.RELEASE.jar；④spring-tx-3.2.0.RELEASE.jar(事务)。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hxeTE3MTkyMzkzMzc_size_16_color_FFFFFF_t_70][]

（4）简单JdbcTemplate应用

①model层

package com.gfy.model;
    
    public class User {
    
    	private Integer id;
    	private String username;
    	private String password;
    	
    	public Integer getId() {
    		return id;
    	}
    	
    	public void setId(Integer id) {
    		this.id = id;
    	}
    	
    	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;
    	}
    	
    	
    	
    }

②创建数据库：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hxeTE3MTkyMzkzMzc_size_16_color_FFFFFF_t_70 1][]

③test层

package com.gfy.test;
    
    import org.apache.commons.dbcp.BasicDataSource;
    import org.junit.Test;
    import org.springframework.jdbc.core.JdbcTemplate;
    
    public class lesson04 {
    
    	 @Test
    		public void test() throws Exception {
    	   //创建数据源
    		 BasicDataSource dataSource=new BasicDataSource();
    		 dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    		 dataSource.setUrl("jdbc:mysql:///spring_day04");// 其中的///代表本地，spring_day04表示你的数据库中的表名字
    		 dataSource.setUsername("root");//root表示你的数据库的登录名
    		 dataSource.setPassword("123456");//123456表示你你的数据库的登录密码
    	    //创建JdbcTemplate
    		
    		 JdbcTemplate jdbcTemplate=new JdbcTemplate(dataSource);
    		jdbcTemplate.update("update t_user set username =? where id=?","aa",1);//表示将id=1的username修改为zzz
    		 System.out.println("成功更新！");
    		
    	}
    }

结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hxeTE3MTkyMzkzMzc_size_16_color_FFFFFF_t_70 2][]

（5）数据源由spring配置

①dao层：接口

package com.gfy.dao;
    
    import com.gfy.model.User;
    
    public interface IUserDao {
           public void add(User user);
          
    }

实现类：

package com.gfy.dao;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.jdbc.core.support.JdbcDaoSupport;
    import org.springframework.stereotype.Repository;
    import com.gfy.model.User;
    @Repository      //Dao层
    public class UserDaoImpl2  implements IUserDao {
    	private JdbcTemplate jdbcTemplate;
        public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
    		this.jdbcTemplate = jdbcTemplate;
    	}
    	@Override
    	public void add(User user) {
    		System.out.println("Dao添加用户"+user);
           jdbcTemplate.update("insert t_user (username,password) values(?,?) ",user.getUsername(),user.getPassword());
    	}
    }

②model层

package com.gfy.model;
    public class User {
    	private Integer id;
    	private String username;
    	private String password;	
    	public Integer getId() {
    		return id;
    	}	
    	public void setId(Integer id) {
    		this.id = id;
    	}	
    	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;
    	}	
    }

③web层，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:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
                            https://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/context
                            https://www.springframework.org/schema/context/spring-context.xsd
                            http://www.springframework.org/schema/aop
                            https://www.springframework.org/schema/aop/spring-aop.xsd">
          
         
         
          
         
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
              <property name="driverClass" value="com.mysql.jdbc.Driver" />
               <property name="jdbcUrl" value="jdbc:mysql:///spring_day04" />
                <property name="user" value="root" />
                 <property name="password" value="123456" />
         </bean>
         
         
          
         <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            <property name="dataSource" ref="dataSource"></property>
         </bean> 
        
        <bean id="userDao" class="com.gfy.dao.UserDaoImpl">
           <property name="jdbcTemplate" ref="jdbcTemplate"></property>
        </bean>
    </beans>

④test层

package com.gfy.test;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import com.gfy.dao.IUserDao;
    import com.gfy.model.User;
    public class lesson05 {
    	 @Test
    		public void test() throws Exception {
    	   /*
    		 //创建数据源
    		  * 
    		 BasicDataSource dataSource=new BasicDataSource();
    		 dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    		 dataSource.setUrl("jdbc:mysql:///spring_day04");// 其中的///代表本地
    		 dataSource.setUsername("root");
    		 dataSource.setPassword("123456");
    	    //创建JdbcTemplate
    		 JdbcTemplate jdbcTemplate=new JdbcTemplate(dataSource);
    		jdbcTemplate.update("update t_user set username ? where id=?","zzz",1);
    	*/
    		ApplicationContext context=new ClassPathXmlApplicationContext("beans05.xml"); 
    		IUserDao userDao=(IUserDao) context.getBean("userDao");
    		 User user=new User();
    		 user.setUsername("gfrfy");
    		 user.setPassword("123657");
    		 userDao.add(user);
    	 }
    }

（6）用JdbcDaoSupport简化JdbcTemplate和配置db.properties（数据库已存在）

把数据库的连接信息配置到一个独立的文件中；在src\[类路径\]写个db.properties文件,然后在xml中配置读取db.properties文件信息。

①配置db.properties

driverClass=com.mysql.jdbc.Driver
    jdbcUrl=jdbc:mysql:///spring_day04
    user=root
    password=123456

![20190731173324228.png][]

②model层

package com.gfy.model;
    
    public class User {
    	private Integer id;
    	private String username;
    	private String password;
    	public Integer getId() {
    		return id;
    	}
    	public void setId(Integer id) {
    		this.id = id;
    	}
    	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;
    	}
    	
    }

③dao层：接口

package com.gfy.dao;
    
    import com.gfy.model.User;
    
    public interface IUserDao {
           public void add(User user);
          
    }

实现类：

package com.gfy.dao;
    import org.springframework.jdbc.core.support.JdbcDaoSupport;
    import org.springframework.stereotype.Repository;
    import com.gfy.model.User;
    @Repository      //Dao层
    public class UserDaoImpl extends JdbcDaoSupport  implements IUserDao {
    	@Override
    	public void add(User user) {
    		System.out.println("Dao添加用户"+user);
           getJdbcTemplate().update("insert t_user (username,password) values(?,?) ",user.getUsername(),user.getPassword());
    	}
    }

④web层，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:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
                            https://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/context
                            https://www.springframework.org/schema/context/spring-context.xsd
                            http://www.springframework.org/schema/aop
                            https://www.springframework.org/schema/aop/spring-aop.xsd">
          
         
         
          
         
         <context:property-placeholder location="classpath:db.properties"/>
         
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
              <property name="driverClass" value="${driverClass}" />
               <property name="jdbcUrl" value="${jdbcUrl}" />
                <property name="user" value="${user}" />
                 <property name="password" value="${password}" />
         </bean>
         
         
          
        
        <bean id="userDao" class="com.gfy.dao.UserDaoImpl">
          
          <property name="dataSource" ref="dataSource"></property>
        </bean>
        
        
    </beans>

⑤test层

[Link 1]: https://baike.baidu.com/item/%E9%A2%84%E7%BC%96%E8%AF%91/3191547
[OOP]: https://baike.baidu.com/item/OOP
[Spring]: https://baike.baidu.com/item/Spring
[Link 2]: https://baike.baidu.com/item/%E5%87%BD%E6%95%B0%E5%BC%8F%E7%BC%96%E7%A8%8B/4035031
[Link 3]: https://baike.baidu.com/item/%E8%80%A6%E5%90%88%E5%BA%A6/2603938
[Link 4]: https://baike.baidu.com/item/%E5%BC%82%E5%B8%B8%E5%A4%84%E7%90%86
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hxeTE3MTkyMzkzMzc_size_16_color_FFFFFF_t_70]: /images/20210923/80bcba9ffc1d4cf891ad9c0772463c05.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hxeTE3MTkyMzkzMzc_size_16_color_FFFFFF_t_70 1]: /images/20210923/34dcf02e496349a394ce5207720e4d95.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hxeTE3MTkyMzkzMzc_size_16_color_FFFFFF_t_70 2]: /images/20210923/97c873b2ab9141059ded453353fb8ae0.png
[20190731173324228.png]: /images/20210923/65d7296d21644009ab374c456643b565.png