企业级开发框架-Spring IOC一.Spring概述 Spring是什么? Spring是分层的 Java SE/E

一.Spring概述

Spring是什么?

Spring是分层的 Java SE/EE应用 full-stack(全栈式) 轻量级开源框架。

提供了表现层 SpringMVC和持久层 Spring JDBC Template以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。

两大核心：以 IOC（Inverse Of Control：控制反转）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

传统的方法需要new一个新的实例才能进行开发,这样的话会出现耦合的问题,即编译器依赖，但是我们使用spring的话这个新的实例对象就会直接冲spring的ioc容器中获得这样编译器依赖就会变成运行时依赖,即解耦合

Spring优势

Spring体系结构

二.IOC

控制反转（Inverse Of Control）不是什么技术，而是一种设计思想。它的目的是指导我们设计出更加松耦合的程序。

IOC与传统开发方式的区别:

自定义IOC容器

需求

实现service层与dao层代码解耦合

自定义IOC容器的步骤

创建java项目，导入自定义IOC相关坐标
编写Dao接口和实现类
编写Service接口和实现类
编写测试代码

代码实现:

创建java项目，导入自定义IOC相关坐标

<dependencies>
 <dependency>
 <groupId>dom4j</groupId>
 <artifactId>dom4j</artifactId>
 <version>1.6.1</version>
 </dependency>
 <dependency>
 <groupId>jaxen</groupId>
 <artifactId>jaxen</artifactId>
 <version>1.1.6</version>
 </dependency>
 <dependency>
 <groupId>junit</groupId>
 <artifactId>junit</artifactId>
<version>4.12</version>
 </dependency>
 </dependencies

编写Dao接口和实现类

public interface UserDao {
 public void save();
 }

 public class UserDaoImpl implements UserDao {
 }
 public void save() {
 System.out.println("保存成功了...");
 }

编写Service接口和实现类

public interface UserService {
 public void save();
 }

 public class UserServiceImpl implements UserService {
 private UserDao userDao;
 }
 public void save(){
 userDao = new UserDaoImpl();
 userDao.save();
 }

编写测试代码

public class UserTest {
 @Test
 public void testSave() throws Exception {
 UserService userService = new UserServiceImpl();
 userService.save();
 }
 }

以上代码出现的问题:

当前service对象和dao对象耦合度太高，而且每次new的都是一个新的对象，导致服务器压力过大。

解耦合的原则是编译期不依赖，而运行期依赖

我们使用Spring的IOC容器来解决耦合问题

编写beans.xml

<?xml version="1.0" encoding="UTF-8" ?>
 <beans>
    <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"></bean>
 </beans>

编写BeanFactory工具类

 public class BeanFactory {
    private static Map<String, Object> ioc = new HashMap<>();
    // 程序启动时，初始化对象实例
    static {
        try {
            // 1.读取配置文件
            InputStream in =BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");

            // 2.解析xml
            SAXReader saxReader = new SAXReader();
            Document document = saxReader.read(in);
            // 3.编写xpath表达式
            String xpath = "//bean";
            // 4.获取所有的bean标签
            List<Element> list = document.selectNodes(xpath);
            // 5.遍历并创建对象实例，设置到map集合中
            for (Element element : list) {
                String id = element.attributeValue("id");
                String className = element.attributeValue("class");
                Object object = Class.forName(className).newInstance();
                ioc.put(id, object);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    // 获取指定id的对象实例
    public static Object getBean(String beandId) {
        return ioc.get(beandId);
    }
 }

修改UserServiceImpl实现类

public class UserServiceImpl implements UserService {
 private UserDao userDao;

 public void save() throws Exception
 userDao = (UserDao) BeanFactory.getBean("userDao");
 userDao.save();
 } }

总结

三 Spring快速入门

需求和步骤分析

需求：借助spring的IOC实现service层与dao层代码解耦合

步骤:

创建java项目，导入spring开发基本坐标
编写Dao接口和实现类
创建spring核心配置文件
在spring配置文件中配置 UserDaoImpl
使用spring相关API获得Bean实例

实现

创建java项目，导入spring开发基本坐标

<dependencies>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context</artifactId>
 <version>5.1.5.RELEASE</version>
 </dependency>
 <dependency>
 <groupId>junit</groupId>
 <artifactId>junit</artifactId>
 <version>4.12</version>
 </dependency>
 </dependencies>

编写Dao接口和实现类

public interface UserDao {
 public void save();
 }

创建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"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd">
 </beans>

在spring配置文件中配置 UserDaoImpl

<beans ...>
 <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"></bean>
 </beans>

使用spring相关API获得Bean实例

public class UserTest {
 @Test
 public void testSave() throws Exception {
 ApplicationContext applicationContext = 
new 
ClassPathXmlApplicationContext("applicationContext.xml");
 UserDao userDao = (UserDao) applicationContext.getBean("userDao");
 userDao.save();
 }
 }

总结:

Spring的开发步骤

四.Spring相关API

API继承体系介绍

Spring的API体系异常庞大，我们现在只关注两个BeanFactory和ApplicationContext

BeanFactory

BeanFactory是 IOC 容器的核心接口，它定义了IOC的基本功能。

特点：在第一次调用getBean()方法时，创建指定对象的实例

BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

ApplicationContext

代表应用上下文对象，可以获得spring中IOC容器的Bean对象。

特点：在spring容器启动时，加载并创建所有对象的实例

常用实现类

ApplicationContext app =new ClassPathXmlApplicationContext("applicationContext.xml");

常用方法

具体用法：

ApplicationContext app = new ClasspathXmlApplicationContext("xml文件");

app.getBean("id");

app.getBean(Class)

五.Spring配置文件

Bean标签基本配置

<bean id="" class=""></bean>

用于配置对象交由Spring来创建。
基本属性： id：Bean实例在Spring容器中的唯一标识 class：Bean的全限定名
默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。

Bean标签范围配置

<bean id="" class="" scope=""></bean>

scope属性指对象的作用范围，取值如下：

 1. 当scope的取值为singleton时
Bean的实例化个数：1个
Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
Bean的生命周期：
对象创建：当应用加载，创建容器时，对象就被创建了
对象运行：只要容器在，对象一直活着
对象销毁：当应用卸载，销毁容器时，对象就被销毁了
2. 当scope的取值为prototype时
Bean的实例化个数：多个
Bean的实例化时机：当调用getBean()方法时实例化Bean
 Bean的生命周期：
对象创建：当使用对象时，创建新的对象实例
对象运行：只要对象在使用中，就一直活着
对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

Bean生命周期配置

<bean id="" class="" scope="" init-method="" destroy-method=""></bean>
 * init-method：指定类中的初始化方法名称
* destroy-method：指定类中销毁方法名称

Bean实例化三种方式

无参构造方法实例化

工厂静态方法实例化

工厂普通方法实例化

无参构造方法实例化

它会根据默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/>

工厂静态方法实例化

使用场景: 依赖的jar包中有个A类，A类中有个静态方法m1，m1方法的返回值是一个B对象。如果我们频繁使用 B对象，此时我们可以将B对象的创建权交给spring的IOC容器，以后我们在使用B对象时，无需调用A类中的m1方法，直接从IOC容器获得。

public class StaticFactoryBean {
 public static UserDao createUserDao(){    
return new UserDaoImpl();
 }
 }

<bean id="userDao" class="com.lagou.factory.StaticFactoryBean" 
factory-method="createUserDao" />

工厂普通方法实例化

使用场景:

依赖的jar包中有个A类，A类中有个普通方法m1，m1方法的返回值是一个B对象。如果我们频繁使用 B对象，此时我们可以将B对象的创建权交给spring的IOC容器，以后我们在使用B对象时，无需调用A类中的m1 方法，直接从IOC容器获得。

public class DynamicFactoryBean {  
public UserDao createUserDao(){        
return new UserDaoImpl(); 
}
 }

 <bean id="dynamicFactoryBean" class="com.lagou.factory.DynamicFactoryBean"/>
 <bean id="userDao" factory-bean="dynamicFactoryBean" factory
method="createUserDao"/>

Bean依赖注入概述

依赖注入 DI（Dependency Injection）：它是 Spring 框架核心 IOC 的具体实现。

在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。

那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。简单的说，就是通过框架把持久层对象传入业务层，而不用我们自己去获取。

Bean依赖注入方式

构造方法

在UserServiceImpl中创建有参构造


public class UserServiceImpl implements UserService {
 private UserDao userDao;
 public UserServiceImpl(UserDao userDao) {
 this.userDao = userDao;
 }
 @Override
 public void save() {
 userDao.save();
 }
 }

配置Spring容器调用有参构造时进行注入

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/>
 <bean id="userService" class="com.lagou.service.impl.UserServiceImpl">
 <!--<constructor-arg index="0" type="com.lagou.dao.UserDao" ref="userDao"/>-->
 <constructor-arg name="userDao" ref="userDao"/>
 </bean>

set方法

在UserServiceImpl中创建有参构造

public class UserServiceImpl implements UserService {
 private UserDao userDao;
 public UserServiceImpl(UserDao userDao) {
 this.userDao = userDao;
 }
 @Override
 public void save() {
 userDao.save();
 }
 }

配置Spring容器调用有参构造时进行注入

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/>
 <bean id="userService" class="com.lagou.service.impl.UserServiceImpl">
 <!--<constructor-arg index="0" type="com.lagou.dao.UserDao" ref="userDao"/>-->
 <constructor-arg name="userDao" ref="userDao"/>
 </bean>

P命名空间注入

P命名空间注入本质也是set方法注入，但比起上述的set方法注入更加方便，主要体现在配置文件中，如下：

首先，需要引入P命名空间：

xmlns:p="http://www.springframework.org/schema/p"

其次，需要修改注入方式：

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"/>
 <bean id="userService" class="com.lagou.service.impl.UserServiceImpl" 
p:userDao-ref="userDao"/>

Bean依赖注入的数据类型

上面操作，都是注入Bean对象，除了对象的引用可以注入，普通数据类型和集合都可以在容器中进行注入。

注入数据的三种数据类型

普通数据类型
引用数据类型
集合数据类型

其中引用数据类型，此处就不再赘述了，之前的操作都是对UserDao对象的引用进行注入的。下面将以set方法注入为例，演示普通数据类型和集合数据类型的注入

注入普通数据类型

public class User {
 private String username;
 private String age;
 public void setUsername(String username) {
 this.username = username;
 }
 public void setAge(String age) {
 this.age = age;
 }
 }


<bean id="user" class="com.lagou.domain.User">
    <property name="username" value="jack"/>
    <property name="age" value="18"/>
 </bean>

注入集合数据类型

List集合注入

 public class UserDaoImpl implements UserDao {
    private List<Object> list;
    public void save() {
        System.out.println(list);
        System.out.println("保存成功了...");
    }
 }

 <bean id="user" class="com.lagou.domain.User">
    <property name="username" value="jack"/>
    <property name="age" value="18"/>
 </bean>
 <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl">
    <property name="list">
        <list>
            <value>aaa</value>
            <ref bean="user"></ref>
        </list>
    </property>
 </bean>

Set集合注入

 public class UserDaoImpl implements UserDao {
    private Set<Object> set;
    public void setSet(Set<Object> set) {
        this.set = set;
    }
    public void save() {
        System.out.println(set);
        System.out.println("保存成功了...");
    }
 }

<bean id="user" class="com.lagou.domain.User">
 <property name="username" value="jack"/>
 <property name="age" value="18"/>
 </bean>
 <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl">
 <property name="set">
 <list>
 <value>bbb</value>
 <ref bean="user"></ref>
 </list>
 </property>
 </bean>

Array数组注入

public class UserDaoImpl implements UserDao {
 private Object[] array;
 public void setArray(Object[] array) {
 this.array = array;
 }

 public void save() {
 System.out.println(Arrays.toString(array));
 System.out.println("保存成功了...");
 } }

 <bean id="user" class="com.lagou.domain.User">
 <property name="username" value="jack"/>
 <property name="age" value="18"/>
 </bean>
 <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl">
 <property name="array">
 <array>
 <value>ccc</value>
 <ref bean="user"></ref>
 </array>
 </property>
 </bean>

Map集合注入

public class UserDaoImpl implements UserDao {
    private Map<String, Object> map;
    public void setMap(Map<String, Object> map) {
        this.map = map;
    }
    public void save() {
        System.out.println(map);
        System.out.println("保存成功了...");
    }
 }

 <bean id="user" class="com.lagou.domain.User">
    <property name="username" value="jack"/>
    <property name="age" value="18"/>
 </bean>
 <bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl">
    <property name="map">
        <map>
            <entry key="k1" value="ddd"/>
            <entry key="k2" value-ref="user"></entry>
        </map>
    </property>
 </bean>

Properties配置注入

 public class UserDaoImpl implements UserDao {
    private Properties properties;
    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    public void save() {
        System.out.println(properties);
        System.out.println("保存成功了...");
    }
 }

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl">
    <property name="properties">
        <props>
            <prop key="k1">v1</prop>
            <prop key="k2">v2</prop>
            <prop key="k3">v3</prop>
        </props>
    </property>
 </bean>

配置文件模块化

实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他配置文件中，也就是所谓的配置文件模块化。

并列的多个配置文件

ApplicationContext act =new ClassPathXmlApplicationContext("beans1.xml","beans2.xml","...");

主从配置文件

<import resource="applicationContext-xxx.xml"/>

注意：同一个xml中不能出现相同名称的bean,如果出现会报错多个xml如果出现相同名称的bean，不会报错，但是后加载的会覆盖前加载的bean

知识小结

Spring的重点配置


<bean>标签：创建对象并放到spring的IOC容器
id属性:在容器中Bean实例的唯一标识，不允许重复
class属性:要实例化的Bean的全限定名
scope属性:Bean的作用范围，常用是Singleton(默认)和prototype

<constructor-arg>标签：属性注入
name属性：属性名称
value属性：注入的普通属性值
ref属性：注入的对象引用值

<property>标签：属性注入
name属性：属性名称
value属性：注入的普通属性值
ref属性：注入的对象引用值
<list>
 <set>
 <array>
 <map>
 <props>
 <import>标签:导入其他的Spring的分文件

六 DbUtils（IOC实战）

DbUtils是什么？

DbUtils是Apache的一款用于简化Dao代码的工具类，它底层封装了JDBC技术

核心对象:

QueryRunner queryRunner = new QueryRunner(DataSource dataSource);

核心方法


int update(); 执行增、删、改语句

T query(); 执行查询语句 ResultSetHandler 这是一个接口，主要作用是将数据库返回的记录封装到实体对象

例: 查询数据库所有账户信息到Account实体中


public class DbUtilsTest {
 @Test
 public void findAllTest() throws Exception {
 // 创建DBUtils工具类，传入连接池
QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
 // 编写sql
 String sql = "select * from account";
 // 执行sql
 List<Account> list = queryRunner.query(sql, new BeanListHandler<Account>
 (Account.class));
 // 打印结果
for (Account account : list) {
 System.out.println(account);
 }
 }
 }

Spring的xml整合DbUtils

需求：基于Spring的xml配置实现账户的CRUD案例

步骤分析

1. 准备数据库环境 
2. 创建java项目，导入坐标 
3. 编写Account实体类 
4. 编写AccountDao接口和实现类 
5. 编写AccountService接口和实现类 
6. 编写spring核心配置文件 
7. 编写测试代码

代码编写:

准备数据库环境

CREATE DATABASE `spring_db`;
 USE `spring_db`;
 CREATE TABLE `account` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(32) DEFAULT NULL,
 `money` double DEFAULT NULL,
 PRIMARY KEY (`id`)
 ) ;
 insert  into `account`(`id`,`name`,`money`) values (1,'tom',1000),
 (2,'jerry',1000);

创建java项目，导入坐标

<dependencies>
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 <version>5.1.47</version>
 </dependency>
 <dependency>
 <groupId>com.alibaba</groupId>
 <artifactId>druid</artifactId>
 <version>1.1.9</version>
 </dependency>
 <dependency>
 <groupId>commons-dbutils</groupId>
 <artifactId>commons-dbutils</artifactId>
 <version>1.6</version>
 </dependency>
 <dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-context</artifactId>
 <version>5.1.5.RELEASE</version>
 </dependency>
 <dependency>
 <groupId>junit</groupId>
 <artifactId>junit</artifactId>
<version>4.12</version>
 </dependency>
 </dependencies>

编写Account实体类

public class Account {
 private Integer id;
 private String name;
 private Double money;
 }

编写AccountDao接口和实现类

public interface AccountDao {
 public List<Account> findAll();
 public Account findById(Integer id);
 public void save(Account account);
 public void update(Account account);

 public void delete(Integer id);
 }


 public class AccountDaoImpl implements AccountDao {
 
private QueryRunner queryRunner;
 
public void setQueryRunner(QueryRunner queryRunner) {

 this.queryRunner = queryRunner;
 }
 @Override
 public List<Account> findAll() {
 
List<Account> list = null;
 // 编写sql
 String sql = "select * from account";
 try {
 // 执行sql
 list = queryRunner.query(sql, new BeanListHandler<Account>
 (Account.class));
 } catch (SQLException e) {
 e.printStackTrace();
 }
 return list;
 }
@Override
    public Account findById(Integer id) {
        Account account = null;
        // 编写sql
        String sql = "select * from account where id = ?";
        try {
            // 执行sql
            account = queryRunner.query(sql, new BeanHandler<Account>
 (Account.class), id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return account;
    }
    @Override
    public void save(Account account) {
        // 编写sql
        String sql = "insert into account values(null,?,?)";
        // 执行sql
        try {
            queryRunner.update(sql, account.getName(), account.getMoney());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void update(Account account) {
        // 编写sql
        String sql = "update account set name = ?,money = ? where id = ?";
        // 执行sql
        try {
            queryRunner.update(sql, account.getName(), 
account.getMoney(),account.getId());
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void delete(Integer id) {
        // 编写sql
        String sql = "delete from account where id = ?";
        // 执行sql
        try {
            queryRunner.update(sql, id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
 }

编写AccountService接口和实现类

public interface AccountService {
 public List<Account> findAll();
 public Account findById(Integer id);
 public void save(Account account);
 public void update(Account account);

 public void delete(Integer id);
 }

 public class AccountServiceImpl implements AccountService {
 private AccountDao accountDao;
 public void setAccountDao(AccountDao accountDao) {
 this.accountDao = accountDao;
 }
 @Override
 public List<Account> findAll() {
 return accountDao.findAll();
 }
 @Override
 public Account findById(Integer id) {
 return accountDao.findById(id);
 }
 @Override
 public void save(Account account) {
 accountDao.save(account);
 }
 @Override
 public void update(Account account) {
 accountDao.update(account);
 }
 @Override
 public void delete(Integer id) {
 accountDao.delete(id);
 }
 }

编写spring核心配置文件

applicationContext.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"
  xsi:schemaLocation="  http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  <!--把数据库连接池交给IOC容器-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver">
 </property>
        <property name="url" value="jdbc:mysql://localhost:3306/spring_db">
 </property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
    <!--把QueryRunner交给IOC容器-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>
    <!--把AccountDao交给IOC容器-->
    <bean id="accountDao" class="com.lagou.dao.impl.AccountDaoImpl">
        <property name="queryRunner" ref="queryRunner"></property>
    </bean>
    <!--把AccountService交给IOC容器-->
    <bean id="accountService" class="com.lagou.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>
 </beans>

编写测试代码:

public class AccountServiceTest {
    ApplicationContext applicationContext =
            new ClassPathXmlApplicationContext("applicationContext.xml");
    AccountService accountService = 
applicationContext.getBean(AccountService.class);
    //测试保存
    @Test
    public void testSave() {
        Account account = new Account();
        account.setName("lucy");
        account.setMoney(100d);
        accountService.save(account);
    }
    //测试查询
    @Test
    public void testFindById() {
        Account account = accountService.findById(3);
        System.out.println(account);
    }
    //测试查询所有
    @Test
public void testFindAll() {
 List<Account> accountList = accountService.findAll();
 for (Account account : accountList) {
 System.out.println(account);
 }
 }
 //测试修改
@Test
 public void testUpdate() {
 Account account = new Account();
 account.setId(3);
 account.setName("jack");
 account.setMoney(2000d);
 accountService.update(account);
 }
 //测试删除
@Test
 public void testDelete() {
 accountService.delete(3);
 }
 }

抽取jdbc配置文件

applicationContext.xml加载jdbc.properties配置文件获得连接信息。

首先，需要引入context命名空间和约束路径：

* 命名空间：
xmlns:context="http://www.springframework.org/schema/context"
 * 约束路径：
http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context.xsd

 <context:property-placeholder location="classpath:jdbc.properties"/>
 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
 <property name="driverClassName" value="${jdbc.driver}"></property>
 <property name="url" value="${jdbc.url}"></property>
 <property name="username" value="${jdbc.username}"></property>
 <property name="password" value="${jdbc.password}"></property>
 </bean>

总结:

* DataSource的创建权交由Spring容器去完成
* QueryRunner的创建权交由Spring容器去完成，使用构造方法传递DataSource
 * Spring容器加载properties文件
<context:property-placeholder location="xx.properties"/>
 <property name="" value="${key}"/

七 Spring注解开发

Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率。

Spring常用注解

Spring常用注解主要是替代的配置

JDK11以后完全移除了javax扩展导致不能使用@resource注解

需要maven引入依赖
<dependency>
 <groupId>javax.annotation</groupId>
 <artifactId>javax.annotation-api</artifactId>
 <version>1.3.2</version>
 </dependency>

使用注解进行开发时，需要在applicationContext.xml中配置组件扫描，作用是指定哪个包及其子包下的Bean需要进行扫描以便识别使用注解配置的类、字段和方法


<!--注解的组件扫描-->
 <context:component-scan base-package="com.lagou"></context:component-scan>

实现

Bean实例化（IOC）

<bean id="userDao" class="com.lagou.dao.impl.UserDaoImpl"></bean>

使用@Compont或@Repository标识UserDaoImpl需要Spring进行实例化。

// @Component(value = "userDao")
 @Repository // 如果没有写value属性值，Bean的id为：类名首字母小写
public class UserDaoImpl implements UserDao {
 }

属性依赖注入（DI）

<bean id="userService" class="com.lagou.service.impl.UserServiceImpl">
 <property name="userDao" ref="userDaoImpl"/>
 </bean>

使用@Autowired或者@Autowired+@Qulifier或者@Resource进行userDao的注入

@Service
 public class UserServiceImpl implements UserService {
 @Autowired
 private UserDao userDao;
 // <property name="userDao" ref="userDaoImpl"/>
 // @Autowired
 // @Qualifier("userDaoImpl")
 // @Resource(name = "userDaoImpl")
 public void setUserDao(UserDao userDao) {
 this.userDao = userDao;
 }
}

@Value

使用@Value进行字符串的注入，结合SPEL表达式获得配置参数

@Service
 public class UserServiceImpl implements UserService {
 @Value("注入普通数据")
 private String str;
 @Value("${jdbc.driver}")
 private String driver;
 }

@Scope

<bean scope=""/>

使用@Scope标注Bean的范围

@Service
 @Scope("singleton")
 public class UserServiceImpl implements UserService {{
 }

Bean生命周期

<bean init-method="init" destroy-method="destory" />

使用@PostConstruct标注初始化方法，使用@PreDestroy标注销毁方法

@PostConstruct
 public void init(){
 System.out.println("初始化方法....");
 }
 @PreDestroy
 public void destroy(){
 System.out.println("销毁方法.....");
 }

Spring常用注解整合DbUtils

步骤

1. 拷贝xml配置项目，改为注解配置项目
2. 修改AccountDaoImpl实现类
3. 修改AccountServiceImpl实现类
4. 修改spring核心配置文件
5. 编写测试代码

修改AccountDaoImpl实现类

@Repository
 public class AccountDaoImpl implements AccountDao {
 @Autowired
 private QueryRunner queryRunner;
 ....
 }

修改AccountServiceImpl实现类

@Service
 public class AccountServiceImpl implements AccountService {
 @Autowired
 private AccountDao accountDao;
 ....
 }

修改spring核心配置文件


<?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w1.org/2001/XMLSchema-instance"
 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="com.lagou"></context:component-scan>
 <!--加载jdbc配置文件-->
 <context:property-placeholder location="classpath:jdbc.properties">
 </context:property-placeholder>
 <!--把数据库连接池交给IOC容器-->
 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
 <property name="driverClassName" value="${jdbc.driver}"></property>
 <property name="url" value="${jdbc.url}"></property>
 <property name="username" value="${jdbc.username}"></property>
 <property name="password" value="${jdbc.password}"></property>
 </bean>
 <!--把QueryRunner交给IOC容器-->
 <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
 <constructor-arg name="ds" ref="dataSource"></constructor-arg>
 </bean>
 </beans>

编写测试代码


public class AccountServiceTest {
 ApplicationContext applicationContext =
 new ClassPathXmlApplicationContext("applicationContext.xml");
 AccountService accountService = 
applicationContext.getBean(AccountService.class);

 //测试查询
@Test
 public void findByIdTest() {
 Account account = accountService.findById(3);
 System.out.println(account);
 } }

Spring新注解

使用上面的注解还不能全部替代xml配置文件，还需要使用注解替代的配置如下：


* 非自定义的Bean的配置：<bean>
 * 加载properties文件的配置：<context:property-placeholder>
 * 组件扫描的配置：<context:component-scan>
 * 引入其他文件：<import>

Spring纯注解整合DbUtils

步骤

1. 编写Spring核心配置类
2. 编写数据库配置信息类
3. 编写测试代码

编写Spring核心配置类

@Configuration 
@ComponentScan("com.lagou") 
@Import(DataSourceConfig.class) 
public class SpringConfig {

 @Bean("queryRunner")
 public QueryRunner getQueryRunner(@Autowired DataSource dataSource) {
 return new QueryRunner(dataSource);
 } }

编写数据库配置信息类


@PropertySource("classpath:jdbc.properties") 
public class DataSourceConfig {
 @Value("${jdbc.driver}")
 private String driver;
 @Value("${jdbc.url}")
 private String url;
 @Value("${jdbc.username}")
 private String username;
 @Value("${jdbc.password}")
 private String password;
 @Bean("dataSource")
 public DataSource getDataSource() {
 DruidDataSource dataSource = new DruidDataSource();
 dataSource.setDriverClassName(driver);
 dataSource.setUrl(url);
 dataSource.setUsername(username);
 dataSource.setPassword(password);
 return dataSource;
}
}

编写测试代码

public class AccountServiceTest {
 ApplicationContext applicationContext =
 new 
AnnotationConfigApplicationContext(SpringConfig.class);
 AccountService accountService = 
applicationContext.getBean(AccountService.class);

 //测试查询
@Test
 public void testFindById() {
 Account account = accountService.findById(3);
 System.out.println(account);
 } }