第二天:Spring整合各种数据源+基于注解的IOC配置+动态代理

一、Spring 整合 DbUtils

（一）Spring 整合 DbUtils

DbUtils是Apache的一款用于简化Dao代码的工具类，它底层封装了JDBC技术。核心类：QueryRunner 用于执行增删改查的SQL语句 ResultSetHandler 这是一个接口，主要作用是将数据库返回的记录封装进实体对象

1、导入依赖的坐标

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.7.RELEASE</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>4.3.7.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>commons-dbutils</groupId>
        <artifactId>commons-dbutils</artifactId>
        <version>1.7</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.15</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>

    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.5.2</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

2、创建数据表

create table Person(

pid int primary key auto_increment,

pname varchar(100) not null unique,

Paddress varchar(100) not null

)

3、创建实体类

public class Person implements Serializable {

private Integer pid;

private String pname;

private String paddress;

}

4、编写持久层代码

public interface PersonDao {

//保存

void save(Person person );

//根据主键查询

Person findByPid(Integer pid);

//查询所有

List<Account> findAll();

}

public class PersonDao Impl implements PersonDao {

QueryRunner queryRunner=null;

public void setQueryRunner(QueryRunner queryRunner) {

this.queryRunner = queryRunner;

}

@Override

public void save(Person person) {

try {

queryRunner.update("insert into person(pname,paddress)value(?,?)",

account.getPname(),

account.getAddress());

} catch (SQLException e) {

e.printStackTrace();

throw new RuntimeException(e);

}；

}

@Override

public Person findByAid(Integer pid) {

try {

//返回值封装到第二个参数位置

return queryRunner.query("select * from person where pid = ?",

new BeanHandler<>(Person.class), pid );

} catch (SQLException e) {

e.printStackTrace();

throw new RuntimeException(e);

}

@Override

public List<Person> findAll() {

try {

//返回值封装到第二个参数位置

return queryRunner.query("select * from person",

new BeanListHandler<>(Person.class) );

} catch (SQLException e) {

e.printStackTrace();

throw new RuntimeException(e);

}

5、编写业务层代码

public interface PersonService {

//保存

void save(Person person);

//根据主键查询

Person findByAid(Integer pid);

//查询所有

List<Person> findAll();

}

public class AccountServiceImpl implements AccountService {

PersonDao personDao;

public void setPersonDao(PersonDao personDao) {

this.personDao= personDao;

}

@Override

public void save(Person person) {

personDao.save(person);

}

@Override

public Person findByAid(Integer pid) {

return personDao.findByAid(pid);

}

@Override

public List<Person> findAll() {

return personDao.findAll();

}

6、创建配置文件

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

</bean>

<constructor-arg name="ds" ref="dataSource"/>

</bean>

</bean>

</bean>

</beans>

7、测试代码

public class PersonServiceTest {

ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("applicationContext.xml");

PersonService personService =

(PersonService ) applicationContext.getBean("personService");

//测试保存

@Test

public void testSave() {

Person person = new Person();

person.setPname("张三");

person.setAddress("济南");

personService .save(person);

}

//测试查询

@Test

public void testFindByAid() {

Person person= personService.findByAid(2);

System.out.println(person);

}

//测试查询所有

@Test

public void testFindAll() {

List<Person> personList = personService.findAll();

for (Person person: personList ) {

System.out.println(person);

}

二、Spring整合各种数据源

Spring中配置数据源非常简单，只要两步：

1、引入数据源坐标

2、在配置文件中配置DataSource的bean

（一）整合C3P0数据源

1、添加依赖坐标：

<groupId>com.mchange</groupId>

</dependency>

2、在Spring配置文件中添加配置内容

</bean>

（二）Spring-jdbc 自带数据源

Spring自带的数据源，没用到池技术，适合开发、测试环境使用

1、添加依赖坐标

<groupId>org.Springframework</groupId>

<artifactId>Spring-jdbc</artifactId>

<version>5.1.5.RELEASE</version>

</dependency>

2、在配置文件中添加数据源的配置

<bean

id="dataSource" class="org.Springframework.jdbc.datasource.DriverManagerDataSource">

</bean>

（三）阿里巴巴数据源 Druid

1、添加依赖坐标

<groupId>com.alibaba</groupId>

<artifactId>druid</artifactId>

</dependency>

2、在配置文件中添加数据源的配置

</bean>

（四）DBCP数据源

1、添加依赖坐标

<groupId>org.apache.commons</groupId>

<artifactId>commons-dbcp2</artifactId>

</dependency>

2、在配置文件中添加数据源的配置信息

</bean>

三、基于注解的IOC配置

(一)常用注解介绍

1、对象实例化注解

@Component

用于实例化对象，相当于配置文件中的< bean id="" class=""/> 它支持一个属性value,相当于xml中bean的id。如果不写，默认值为类名的首字母小写

@Controller

@Service

@Repository

这三个注解的功能跟@Component完全一样，只不过他们三个比较有语义化。

@Controller 一般标注在变现层的类上

@Service 一般标注在业务层的类上

@Repository 一般标注在持久层的类上

推荐使用这三个，当一个类实在不好归属在这三个层上时，再使用@Component！！！

2、依赖注入的注解

@Autowired 按照类型注入。

相当于配置文件中的< property name="" ref="">

当使用注解注入属性时，set 方法可以省略。

当要注入的属性存在多个实现类时会报错。

@Qualifier

在@Autowired注入的基础之上，再按照 Bean 的 id 注入。

一般在@Autowired注入存在多个实现类的时候，使用@Qualifier按照bean的id选取

@Resource 直接按照 Bean 的 id 注入

@Value

用于简单数据类型的注入，相当于< property name="" value="" >

3、用于改变注入范围的注解

@Scope

用于指定bean的作用范围，相当于配置文件中的< bean scope="">

（二）基于注解的IOC配置

1、创建工程引入坐标

<groupId>org.Springframework</groupId>

<artifactId>Spring-context</artifactId>

<version>5.1.5.RELEASE</version>

</dependency>

</dependencies>

2、使用@Component注解配置管理的资源

//使用@Component向Spring声明一个bean，

//相当于xml中<bean id="book" class="com.itheima.anno.Book" />

@Component("book")

public class Book {

private int bid;

private String bname;

private double bprice;

}

3、创建配置文件，并开启注解的支持

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

<context:component-scan base-package="com.offcn"/>

</beans>

4、测试

public class TestSpringAnno {

ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("applicationContext.xml");

@Test public void test() {

Book book = (Book) applicationContext.getBean("book");

book.desc();

}

（三）注解案例

1、基于注解的CRUD

拷贝原来的案例工程进行修改

(1)使用注解修改持久层内容

@Repository("personDao")

public class PersonDaoImpl implements PersonDao {

@Autowired

private QueryRunner queryRunner;

//其余代码跟原来一模一样

}

(2)使用注解修改业务层

@Service("personService")

//使用注解完成bean的声明

//相当于xml中的

public class PersonServiceImpl implements PersonService {

//使用注解完成依赖注入

@Autowired

private PersonDao personDao;

//其余代码跟原来一模一样

}

（3）调整配置文件，去掉关于service和dao的bean

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

<context:component-scan base-package="com.offcn" />

</bean>

<constructor-arg name="ds" ref="dataSource"/>

</bean>

</beans>

（4）测试代码

使用原来的代码即可

四、Spring和junit的整合

这是Spring提供的对Junit单元测试的一种支持。使用步骤如下:

1：引入坐标

<groupId>org.Springframework</groupId>

<artifactId>Spring-test</artifactId>

<version>5.1.5.RELEASE</version>

</dependency>

2：在测试类上使用@RunWith指定Spring的单元测试运行器

@RunWith(SpringJUnit4ClassRunner.class)

public class PersonServiceTest {

}

3:使用@ContextConfiguration指定配置文件，它支持文件和类的形式

@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml")

public class PersontServiceTest {

}

4:下面可以直接使用@Autowired的形式，让Spring容器为我们注入需要的bean了

@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml")

public class PersonServiceTest {

@Autowired

PersonService personService

}

五、动态代理模式详解

（一）动态代理模式简介

代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。简单的说就是，我们在访问实际对象时，是通过代理对象来访问的，代理模式就是在访问实际对象时引入一定程度的间接性

代理类在程序运行时创建的代理方式被成为动态代理。动态代理是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。

（二）动态代理模式入门案例

需求： A账户需要转账给B账户

1、 Version 1.0 使用传统的分层调用方式，同时在service中添加事务管理

（1）构建我们的Dao层代码

public class AccountDaoImpl implements AccountDao {

//创建QueryRunner的时候不再传入数据源

private QueryRunner queryRunner = new QueryRunner();

private Connection connection;

//在构造方法中传入Connection，这样就可以保证SQL语句使用的是同一个connection

public AccountDaoImpl(Connection connection) {

this.connection = connection;

}

@Override

public Account findByName(String name) {

//在执行的时候传入connection，connection相同，事务就相同

return queryRunner.query(connection,"select * from account where name = ?",

new BeanHandler<Account>(Account.class), name);

}

@Override

public void updateByName(Account account) {

queryRunner.update(connection,"update account set balance = ? where name = ?",

account.getBalance(), account.getName());

}

（2）构建Service服务层代码

public class AccountServiceImpl implements AccountService {

Connection connection = DataSourceUtil.getConnection();

private AccountDao accountDao = new AccountDaoImpl(connection);

@Override

public void transfer(String sourceAccountName, String targetAccountName, Float amount) {

try {

connection.setAutoCommit(false);

//查询余额

Account sourceAccount = accountDao.findByAccountName(sourceAccountName);

Account targetAccount = accountDao.findByAccountName(targetAccountName);

//增减

sourceAccount.setBalance(sourceAccount.getBalance() - amount);

targetAccount.setBalance(targetAccount.getBalance() + amount);

//更新余额

accountDao.update(sourceAccount);

//int i = 1 / 0;

accountDao.update(targetAccount);

connection.commit();

} catch (Exception e) {

System.out.println("业务出现异常");

try {

connection.rollback();

} catch (SQLException ex) {

ex.printStackTrace();

}

代码问题：Connection是数据库连接，属于持久层的东西，但现在却跑到了业务层里，又出现了层次混乱。

2、 V2.0 从业务层剥离跟持久层相关的代码

使用ThreadLocal从业务层剥离跟持久层相关的代码

（1）创建一个事务管理器的工具类，使用ThreadLocal存放Connection

public class TxManager {

private static ThreadLocal<Connection> tl = new ThreadLocal<>();

//获取连接

public static Connection getConnection() {

Connection connection = tl.get();

if (connection == null) {

connection = DataSourceUtil.getConnection();

tl.set(connection);

}

return connection;

}

//开启事务

public static void begin() {

try {

getConnection().setAutoCommit(false);

} catch (SQLException e) {

e.printStackTrace();

}

//提交事务

public static void commit() {

try {

getConnection().commit();

} catch (SQLException e) {

e.printStackTrace();

}

//回滚事务

public static void rollback() {

try {

getConnection().rollback();

} catch (SQLException e) {

e.printStackTrace();

}

//关闭事务

public static void close() {

try {

getConnection().close();

tl.remove();

} catch (SQLException e) {

e.printStackTrace();

}

（2）构建service服务层代码：

public class AccountServiceImpl implements AccountService {

private AccountDao accountDao = new AccountDaoImpl();

@Override

public void transfer(String sourceAccountName, String targetAccountName, Float amount) {

try {

TxManager.begin();

//查询余额

Account sourceAccount = accountDao.findByAccountName(sourceAccountName);

Account targetAccount = accountDao.findByAccountName(targetAccountName);

//增减

sourceAccount.setBalance(sourceAccount.getBalance() - amount);

targetAccount.setBalance(targetAccount.getBalance() + amount);

//更新余额

accountDao.update(sourceAccount);

int i = 1 / 0;

accountDao.update(targetAccount);

TxManager.commit();

} catch (Exception e) {

System.out.println("业务出现异常");

TxManager.rollback();

} finally {

TxManager.close();

}

（3）构建数据操作层Dao代码

public class AccountDaoImpl implements AccountDao {

private QueryRunner queryRunner = new QueryRunner();

@Override

public Account findByAccountName(String accountName) {

try {

return queryRunner.query(TxManager.getConnection(),

"select * from account where name = ?",

new BeanHandler<>(Account.class), accountName);

} catch (Exception e) {

throw new RuntimeException(e);

}

@Override

public void update(Account account) {

try {

queryRunner.update(TxManager.getConnection(), "update account set balance = ? where name = ?",

account.getBalance(), account.getName());

} catch (Exception e) {

throw new RuntimeException(e);

}

代码问题：在业务层的代码中存在一些跟业务无关、跟事务相关的公共代码。

3、 V3.0 使用动态代理优化代码

（1）GDK动态代理是基于接口实现的

a.创建动态代理类

//动态代理类

public class AccountServiceProxyImpl implements InvocationHandler {

private AccountService target;

//传进来的就是被代理类

public AccountServiceProxyImpl(AccountService target) {

this.target = target;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

try {

TxManager.begin();

//调被代理类实现核心业务

//target.transfer(sourceAccountName, targetAccountName, amount);

method.invoke(target,args);

TxManager.commit();

} catch (Exception e) {

System.out.println("业务出现异常");

TxManager.rollback();

} finally {

TxManager.close();

}

return null;

}

b.测试

public class AccountTest {

private AccountService accountService = new AccountServiceImpl();

@Test

public void testTransfer() {

//ClassLoader loader, 类加载器，因为代理类是运行时才真正产生的，所以需要类

加载器的加载。跟被代理类使用同一个

//Class<?>[] interfaces, 接口，就是用被代理类实现的接口，目的是使得代理类和被

代理类拥有相同的方法

//InvocationHandler h 代理策略，里面是我们的道理逻辑

AccountService instance = (AccountService) Proxy.newProxyInstance(

accountService.getClass().getClassLoader(),

accountService.getClass().getInterfaces(),

new AccountServiceProxyImpl(accountService)

);

instance.transfer("A01","A02",2F);

}

代码问题：GDK动态代理要求被代理类一定要有接口，当没有接口时便无法使用了。

(2)CGLIB动态代理

CGLIB动态代理是基于子类实现的

a.添加依赖

<groupId>cglib</groupId>

<artifactId>cglib</artifactId>

</dependency>

b.构建动态代理工具类

public class AccountServiceProxyImpl implements InvocationHandler {

private AccountServiceImpl target;

//传进来的就是被代理类

public AccountServiceProxyImpl(AccountServiceImpl target) {

this.target = target;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

try {

TxManager.begin();

//调被代理类实现核心业务

//target.transfer(sourceAccountName, targetAccountName, amount);

method.invoke(target,args);

TxManager.commit();

} catch (Exception e) {

System.out.println("业务出现异常");

TxManager.rollback();

} finally {

TxManager.close();

}

return null;

}

c.测试

public class AccountTest {

private AccountServiceImpl accountService = new AccountServiceImpl();

@Test

public void testTransfer() {

Enhancer enhancer = new Enhancer();

//设置父类

enhancer.setSuperclass(AccountServiceImpl.class);

//设置增强

enhancer.setCallback(new AccountServiceProxyImpl(accountService));

//获取代理后的实例

AccountServiceImpl instance = (AccountServiceImpl) enhancer.create();

instance.transfer("A01", "A02", 2F);

}

通过上面的案例，我们体会到一种新的编程思想：

当核心业务（转账）和增强业务（事务）同时出现时，我们可以在开发时对他们分别开发，运行时再组装在一起（使用动态代理的方式）。

这样做的好处是：

1. 逻辑清晰，开发核心业务的时候，不必关注增强业务的代码

2. 代码复用性高：增强代码不用重复书写

这就是一种AOP的思想。