Spring框架学习笔记3：aop操作的注解方式，jdbcTemplate技术，spring配置连接池 ， spring的事务操作

这是黑马视频的学习笔记

一、

基于AspectJ的注解实现AOP操作

1.1 导入Spring基本JAR包

1.2 创建被增强类和增强类

1. 被增强类Book，实例注解方式创建Book Bean

package com.spring.annotationAOP;
import org.springframework.stereotype.Component;

@Component("book")
public class Book {
    public void add(){
        System.out.println("book add...");
    }
}

1. 增强类Mybook，实例注解方式创建Book Bean

2. 在增强类上需要添加@Aspect注解

3. 在增强的方法上需要添加下面五种注解声明通知方法
   
   • @Before – 前置增强
   • @Before – 后置增强
   • @AfterReturning – 后置增强
   • @AfterThrowing –抛出异常后增加
   • @Around –前后增强

package com.spring.annotationAOP;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component("myBook")
@Aspect
public class Mybook {
    @Autowired
    private Book book;

    @After("execution(* com.spring.annotationAOP.Book.*(..))")
    //使用注解方式，表达式添加切入点
    public void afterAdd(){
        System.out.println("mybook add...");
    }
}

1.3 配置Spring核心文件bean3.xml

1. 需要开启AOP自动代理
2. 需要添加相应的schema约束(aop,context)

<?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 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"> <!-- bean definitions here -->

    <!-- 开启注解扫描，在包里面扫描类、方法、属性上面是否有注解 -->
    <context:component-scan base-package="com.spring.annotationAOP"></context:component-scan>

    <!-- 开启AOP自动代理 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

1.4 测试代码

package test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.spring.annotationAOP.Book;

public class AOPannotationTest {
    @Test
    public void testAopAnnotation(){
        ApplicationContext context = new ClassPathXmlApplicationContext("aopAnnotation.xml");
        Book book = (Book) context.getBean("book");
        book.add();
    }
}

二、 Spring 中的JDBCTemplate对JDBC进行了封装

2.1 添加相关的JAR包

spring-jdbc,spring-tx(事务),mysql驱动包

2.2 创建对象，设置数据库信息

DriverManagerDataSource source = new DriverManagerDataSource();
source.setDriverClassName("com.mysql.cj.jdbc.Driver");
source.setUrl("jdbc:mysql://localhost:3306/my?useUnicode=true&characterEncoding=UTF-8");
source.setUsername("root");
source.setPassword("666666");

• 1
• 2
• 3
• 4
• 5

2.3 创建JDBCTemplate对象，设置数据库

JdbcTemplate template = new JdbcTemplate(source);

2.4 调用JDBCTemplate对象里面的方法实现操作

String sql = "insert into grade value(?,?,?)";
int row = template.update(sql,5,"C++高级班","数据库操作");  //返回的是数据库影响行数

• 1
• 2

2.5 实现增删改操作

package test;

import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

public class TestJDBC {
    JdbcTemplate template;
    public void upload(){
        //设置数据库信息
        DriverManagerDataSource source = new DriverManagerDataSource();
        source.setDriverClassName("com.mysql.jdbc.Driver");
        source.setUrl("jdbc:mysql://localhost:3306/my?useUnicode=true&characterEncoding=UTF-8");
        source.setUsername("root");
        source.setPassword("");
        //创建JDBCTemplate对象，设置数据源
       JdbcTemplate template = new JdbcTemplate(source);
    }
    @Test//添加操作
    public void add(){
        upload();
        //调用JDBCTemplate对象里面的方法实现操作
        String sql = "insert into grade value(?,?,?)";//创建SQL语句
        int row = template.update(sql,5,"C++高级班","数据库操作");
        System.out.println(row);
        //返回的是数据库影响行数       
    }
    @Test
    //修改操作
    public void update(){
        upload();
        String sql = "update grade set GNAME=? where GID=?";
        int row = template.update(sql,"C#",5);
        System.out.println(row);
    }
    @Test//删除操作
    public void delete(){
        upload();
        String sql = "delete from grade where GID=?";
        int row = template.update(sql,5);
        System.out.println(row);
    }
}

2.6 实现查询功能

2.6.1 查询单个

@Test//获取表中数据个数操作
    public void count(){
        upload();
        String sql = "select count(*) from grade";
        int row = template.queryForObject(sql, Integer.class);
        System.out.println(row);
    }

• 1
• 2
• 3
• 4
• 5
• 6
• 7

2.6.2 查询单个对象

将数据库中的查询结果转换成类对象

1. 创建Grade类

package com.spring.jdbc;

public class Grade {
    private int gid;
    private String gName;
    private String gDesc;
    public String getgDesc() {
        return gDesc;
    }
    public void setgDesc(String gDesc) {
        this.gDesc = gDesc;
    }
    public String getgName() {
        return gName;
    }
    public void setgName(String gName) {
        this.gName = gName;
    }
    public int getGid() {
        return gid;
    }
    public void setGid(int gid) {
        this.gid = gid;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "[GName:]"+gName+",[GDesc:]"+gDesc;
    }
}

• 2

4. 测试类的整体代码

package test;

import java.sql.ResultSet;
import java.sql.SQLException;
import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import com.spring.jdbc.Grade;

public class TestJDBC {
    JdbcTemplate template;
    public void upload(){
        //设置数据库信息
        DriverManagerDataSource source = new DriverManagerDataSource();
        source.setDriverClassName("com.mysql.jdbc.Driver");
        source.setUrl("jdbc:mysql://localhost:3306/my?useUnicode=true&characterEncoding=UTF-8");
        source.setUsername("root");
        source.setPassword("");
        //创建JDBCTemplate对象，设置数据源
        template = new JdbcTemplate(source);
    }
    @Test//添加操作
    public void add(){
        upload();
        //调用JDBCTemplate对象里面的方法实现操作
        String sql = "insert into grade value(?,?,?)";//创建SQL语句
        int row = template.update(sql,5,"C++高级班","数据库操作");
        System.out.println(row);
        //返回的是数据库影响行数       
    }
    @Test
    //更新操作
    public void update(){
        upload();
        String sql = "update grade set GNAME=? where GID=?";
        int row = template.update(sql,"C#",5);
        System.out.println(row);
    }
    @Test//删除操作
    public void delete(){
        upload();
        String sql = "delete from grade where GID=?";
        int row = template.update(sql,5);
        System.out.println(row);
    }
    @Test//获取表中数据个数操作
    public void count(){
        upload();
        String sql = "select count(*) from grade";
        int row = template.queryForObject(sql, Integer.class);//返回类型的class
        System.out.println(row);
    }
    
     //查询某个对象

@Test
public void getObject(){
 upload();
String sql = "select * from grade where gid=?";rade grade = template.queryForObject(sql, new MyRowMapper(), 4);//返回对象的方法，第二个参数是一个接口
//
 System.out.println(grade); }

//接口的实现类 

 class MyRowMapper implements RowMapper<Grade>{ @Override//实现接口里面的方法 public Grade mapRow(ResultSet arg0, int arg1) throws SQLException { Grade grade = new Grade();//从结果集中得到数据，封装到对象里面 grade.setgName(arg0.getString("GName")); grade.setgDesc(arg0.getString("GDesc")); return grade; }}
}

2.6.3 查询list集合

//查询list集合

@Test
public void getList(){
 upload();
String sql = "select * from grade ";List<Grand> list = template.query(sql, new MyRowMapper());//返回对象的方法，第二个参数是一个接口
//
 System.out.println(list); }

三、spring配置连接池和dao使用jdbcTemplate

3.1 spring配置C3P0连接池

导入jar包（c3p0包和mchange-commons-java包）=====》在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">
     <!-- 创建连接池  配置连接池的属性值 -->
     <bean id="ds" class="com.mchange.v2.c3p0.ComboPooledDataSource">
         <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
         <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/c3p0jdbctemplate"></property>
        <property name="user" value="root"></property>
        <property name="password" value="666666"></property>
     </bean>
     
    <!-- dao中注入jdbctemplate对象 -->
     <bean id="dao" class="org.dao.Dao">
         <property name="jdbcTemplate" ref="jdbctemplate"></property>
     </bean>                
     
     <!-- service中注入dao对象 -->
     <bean id="service" class="org.service.Service">
         <property name="dao" ref="dao"></property>
     </bean>
     
     <!-- 创建jdbctemplate对象  并且向其中注入连接池对象  dateSource是该对象中数据源的属性 -->
     <bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate">
         <property name="dataSource" ref="ds"></property>
   </bean>

 </beans>

3.2 dao使用jdbcTemplate

先创建service类。

 package org.service;
 import org.dao.*;
  public class Service {
      //想在service中调用dao对象的add方法   创建dao对象  生成对应的set方法 
      private Dao dao;
      
      //生成set方法  注入dao对象
      public void setDao(Dao dao){
          this.dao=dao;
     }    
     public void add(){
         dao.add();
     }
 }

再创建Dao类，在类中使用jdbcTemplate

package org.dao;
  import java.beans.PropertyVetoException;
  
  import org.springframework.jdbc.core.JdbcTemplate;
  import org.springframework.jdbc.datasource.DriverManagerDataSource;
  
  import com.mchange.v2.c3p0.ComboPooledDataSource;
  
  public class Dao {
    private JdbcTemplate jdbcTemplate;
     
     //设置set方法  为了之后的注入
     public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
         this.jdbcTemplate = jdbcTemplate;
    }
     public void add(){    
        String sql="insert into User(name,password) values(?,?)";
         jdbcTemplate.update(sql,"joke2",520);        
         System.out.println("增加了一条信息。。。。。。。");
     }
 }

配置文件的代码

 <!-- dao中注入jdbctemplate对象 -->
     <bean id="dao" class="org.dao.Dao">
         <property name="jdbcTemplate" ref="jdbctemplate"></property>
     </bean>                
     
     <!-- service中注入dao对象 -->
     <bean id="service" class="org.service.Service">
         <property name="dao" ref="dao"></property>
     </bean>
     
     <!-- 创建jdbctemplate对象  并且向其中注入连接池对象  dateSource是该对象中数据源的属性 -->
     <bean id="jdbctemplate" class="org.springframework.jdbc.core.JdbcTemplate">
         <property name="dataSource" ref="ds"></property>
   </bean>

测试代码

package org.test;
  import org.junit.Test;
 import org.service.Service;
 import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
 
  public class TestDemo {
     public static void main(String args[]){
          ApplicationContext ac=new ClassPathXmlApplicationContext("bean3.xml");
         Service s=(Service) ac.getBean("service");
         s.add();
     }
 }

 四、spring的事务操作

4.1事务概念

隔离性：多个事务之间互不影响

4.2 spring事务管理的api

1.编程式事务管理（不用）

2.声明式事务管理（常用），可以用配置文件，也可以用注解（常用）

3.api 

接口：Spring事务管理的核心接口是PlatformTransactionManager

Spring提供了许多内置事务管理器实现：

• DataSourceTransactionManager：位于org.springframework.jdbc.datasource包中，数据源事务管理器，提供对单个javax.sql.DataSource事务管理，用于Spring JDBC抽象框架、iBATIS或MyBatis框架的事务管理；  
  
• JdoTransactionManager：位于org.springframework.orm.jdo包中，提供对单个javax.jdo.PersistenceManagerFactory事务管理，用于集成JDO框架时的事务管理；
• JpaTransactionManager：位于org.springframework.orm.jpa包中，提供对单个javax.persistence.EntityManagerFactory事务支持，用于集成JPA实现框架时的事务管理；
• HibernateTransactionManager：位于org.springframework.orm.hibernate3包中，提供对单个org.hibernate.SessionFactory事务支持，用于集成Hibernate框架时的事务管理；该事务管理器只支持Hibernate3+版本，且Spring3.0+版本只支持Hibernate 3.2+版本；
• JtaTransactionManager：位于org.springframework.transaction.jta包中，提供对分布式事务管理的支持，并将事务管理委托给Java EE应用服务器事务管理器；
• OC4JjtaTransactionManager：位于org.springframework.transaction.jta包中，Spring提供的对OC4J10.1.3+应用服务器事务管理器的适配器，此适配器用于对应用服务器提供的高级事务的支持；
• WebSphereUowTransactionManager：位于org.springframework.transaction.jta包中，Spring提供的对WebSphere 6.0+应用服务器事务管理器的适配器，此适配器用于对应用服务器提供的高级事务的支持；
• WebLogicJtaTransactionManager：位于org.springframework.transaction.jta包中，Spring提供的对WebLogic 8.1+应用服务器事务管理器的适配器，此适配器用于对应用服务器提供的高级事务的支持。

4.3配置事务管理器

搭建转账环境：先建数据库和表=====》创建service和dao类，完成注入关系=====

创建service类和dao类， 完成注入关系的代码

package cn.itcast.service;

import cn.itcast.dao.OrderDao;

public class OrderService {
   private  OrderDao orderDao;

public void setOrderDao(OrderDao orderDao) {
	this.orderDao = orderDao;
}
   
}

package cn.itcast.dao;

import org.springframework.jdbc.core.JdbcTemplate;

public class OrderDao {
  private JdbcTemplate jdbcTemplate;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
	this.jdbcTemplate = jdbcTemplate;
}
  
}

spring核心配置文件代码

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	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/mvc    
            http://www.springframework.org/schema/mvc/spring-mvc.xsd  
            http://www.springframework.org/schema/tx   
            http://www.springframework.org/schema/tx/spring-tx.xsd  
            http://www.springframework.org/schema/aop  
            http://www.springframework.org/schema/aop/spring-aop.xsd "
	default-autowire="byName">
	
	<!-- 配置C3P0连接池 -->
   <bean  id="dataSource" class="com.mchange.v2.c3p0.CombopooledDataSource">
    <!-- 注入属性值 -->
     <property name="driverClass"  value="com.mysql.cj.jdbc.Driver"></property>
    <property name="jdbcUrl"  value="jdbc:mysql:///spring_day03-tx"></property>
    <property name="user"  value="root"></property>
     <property name="password"  value="666666"></property>
   </bean>
   
 <bean  id="orderService" class="cn.itcast.service.OrderService">
   <property name="orderDao" ref="orderDao"></property>
   </bean>

 <bean  id="orderDao" class="cn.itcast.dao.OrderDao">
   
   <property name="jdbcTemplate" ref="jdbcTemplate"></property>
   
   </bean>

 <bean  id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
     <property name="dataSource"  ref="dataSource"></property>
   </bean>

</beans>

====》转账逻辑的代码：===》

package cn.itcast.dao;

import org.springframework.jdbc.core.JdbcTemplate;

public class OrderDao {
  private JdbcTemplate jdbcTemplate;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
	this.jdbcTemplate = jdbcTemplate;
}
  
public void lessMoney() {
	String sql="updat account set salary=salary-1000 where username=?";
	jdbcTemplate.update(sql,1000,"小王");
}
  public void moreMoney() {
	  String sql="updat account set salary=salary+1000 where username=?";
		jdbcTemplate.update(sql,1000,"小 马");	  
}

}

package cn.itcast.service;

import cn.itcast.dao.OrderDao;

public class OrderService {
   private  OrderDao orderDao;

public void setOrderDao(OrderDao orderDao) {
	this.orderDao = orderDao;
}
public void zhuanZhang() {
	orderDao.lessMoney();
	orderDao.moreMoney();
}

}

====》添加事务操作（声明式，xml配置文件，少用）

配置事务管理器的代码

<!-- 配置C3P0连接池 -->
   <bean  id="dataSource" class="com.mchange.v2.c3p0.CombopooledDataSource">
    <!-- 注入属性值 -->
     <property name="driverClass"  value="com.mysql.cj.jdbc.Driver"></property>
    <property name="jdbcUrl"  value="jdbc:mysql:///spring_day03-tx"></property>
    <property name="user"  value="root"></property>
     <property name="password"  value="666666"></property>
   </bean>
   
   <!--配置事务管理器  -->
   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
   <property name="dataSource" ref="dataSource"></property>
   </bean>
   

配置事务增强的代码

<!--配置事务管理器  -->
   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
   <property name="dataSource" ref="dataSource"></property>
   </bean>
   
   <!-- 配置事务增强  -->
   <tx:advice  id="txadvice" transaction-manager="transactionManager">
    <!-- 做事务操作 -->
     <tx:attributes>
     <!--设置进行事务操作的方法匹配规则  -->
     <tx:method name="account*"/>
     </tx:attributes>
   </tx:advice>
   

配置切面的代码：

	<!-- 配置C3P0连接池 -->
   <bean  id="dataSource" class="com.mchange.v2.c3p0.CombopooledDataSource">
    <!-- 注入属性值 -->
     <property name="driverClass"  value="com.mysql.cj.jdbc.Driver"></property>
    <property name="jdbcUrl"  value="jdbc:mysql:///spring_day03-tx"></property>
    <property name="user"  value="root"></property>
     <property name="password"  value="666666"></property>
   </bean>
   
   <!--配置事务管理器  -->
   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
   <property name="dataSource" ref="dataSource"></property>
   </bean>
   
   <!-- 配置事务增强  -->
   <tx:advice  id="txadvice" transaction-manager="transactionManager">
    <!-- 做事务操作 -->
     <tx:attributes>
     <!--设置进行事务操作的方法匹配规则  -->
     <tx:method name="account*"/>
     </tx:attributes>
   </tx:advice>
   
   <!--配置切面  -->
   <aop:config>
   <!--配置切入点  -->
   <aop:pointcut expression="execution(*cn.itcast.service.OrderService.*(..))" id="pointcut1"/>
   <!--切面  -->
   <aop:advisor advice-ref="txadvice" pointcut-ref="pointcut1"/>
   </aop:config>
   
   

=======》注解方式添加事务

配置事务管理器代码和开启事务注解代码

	<!-- 配置C3P0连接池 -->
   <bean  id="dataSource" class="com.mchange.v2.c3p0.CombopooledDataSource">
    <!-- 注入属性值 -->
     <property name="driverClass"  value="com.mysql.cj.jdbc.Driver"></property>
    <property name="jdbcUrl"  value="jdbc:mysql:///spring_day03-tx"></property>
    <property name="user"  value="root"></property>
     <property name="password"  value="666666"></property>
   </bean>
   
   <!--配置事务管理器  -->
   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
   <property name="dataSource" ref="dataSource"></property>
   </bean>
   
  <!-- 开启事务注解扫描  -->
   <tx:annotation-driven transaction-manager="transactionManager"/>
   

被增加事务功能的方法的类的代码

@Transactional
public class OrderService {
   private  OrderDao orderDao;

public void setOrderDao(OrderDao orderDao) {
	this.orderDao = orderDao;
}
   

public void zhuanZhang() {
	orderDao.lessMoney();
	orderDao.moreMoney();
}

}