Spring_two

Spring_two

基于注解的IOC配置

准备工作(参考上一篇)

  1.  <dependencies>
  2.  <dependency>
  3.  <groupId>org.springframework</groupId>
  4.  <artifactId>spring-context</artifactId>
  5.  <version>5.0.2.RELEASE</version>
  6.  </dependency>
  7.  </dependencies>

创建接口AccountDao.java

  1. /**
  2. * 账户的持久层接口
  3. */
  4. public interface AccountDao {
  5.  /**
  6.      * 模拟保存账户
  7.      */
  8.  void saveAccount();
  9. }

创建实现类AccountDaoImpl.java

  1. /**
  2. * 账户的持久层实现类
  3. */
  4. public class AccountDaoImpl implements AccountDao {
  6.  public void saveAccount(){
  7.  System.out.println("AccountDaoImpl实现了接口AccountDao的保存方法");
  8.  }
  9. }

创建接口AccountService.java

  1. /**
  2. * 账户业务层的接口
  3. */
  4. public interface AccountService {
  5.  /**
  6.      * 模拟保存账户
  7.      */
  8.  void saveAccount();
  9. }

创建接口的实现类，AccountServiceImpl.java

  1. public class AccountServiceImpl implements AccountService {
  2.  //注入
  3.  private AccountDao accountDao;
  5. public void setAccountDao(AccountDao accountDao) {
  6.  this.accountDao = accountDao;
  7.  }
  9.  public void  saveAccount(){
  10.         accountDao.saveAccount();
  11.  }
  12. }

用applicationContext.xml的方式完成配置（配置文件的IOC和DI）

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.  xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.         http://www.springframework.org/schema/beans/spring-beans.xsd">
  7.  <bean id="accountDao" class="com.it.dao.impl.AccountDaoImpl"></bean>
  9.  <bean id="accountService" class="com.it.service.impl.AccountServiceImpl">
  10.  <property name="accountDao" ref="accountDao"></property>
  11.  </bean>
  12. </beans>

测试类

  1. public class Client {
  3.  public static void main(String[] args) {
  4.  // 工厂类加载spring的配置文件
  5.  ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
  6.  AccountService accountService = ac.getBean("accountService", AccountService.class);
  7.         accountService.saveAccount();
  8.  }
  9. }

注解配置-控制反转IOC

以前的XML配置

  1. <bean id="accountService" class="com.it.service.impl.AccountServiceImpl" scope="" init-method="" destroy-method="">
  2.  <property name="" value="" | ref=""></property>
  3. </bean>

用于创建对象的

​ 他们的作用就和在XML配置文件中编写一个标签实现的功能是一样的 
（1）@Component: 
​

  • ​ 作用：用于把当前类对象存入spring容器中 
    ​
  • ​ 属性： 
    value：用于指定bean的id。当我们不写时，它的默认值是当前类名，且首字母改小写。

（2）Spring中提供了@Component的衍生注解：

  • @Controller ：用来修饰WEB层类（控制层）（springMVC延用了该注解）
  • @Service ：用来修饰service层类（业务层）
  • @Repository ：用来修饰DAO层类（持久层）

以上三个注解他们的作用和属性与Component是一模一样。 
他们三个是spring框架为我们提供明确的三层使用的注解，使我们的三层对象更加清晰。

  1. /**
  2. * 账户的持久层实现类
  3. */
  4. @Repository("accountDao1")//指定以”accountDao1”的ID存入Spring
  5. public class AccountDaoImpl implements AccountDao {
  7.  public void saveAccount(){
  8.  System.out.println("AccountDaoImpl实现了接口AccountDao的保存方法");
  9.  }
  10. }

替代了

1561866842891

AccountServiceImpl.java

  1. /**
  2. * 账户的业务层实现类
  3. */
  4. @Service("accountService1")//指定以”accountService”的ID存入Spring
  5. public class AccountServiceImpl implements AccountService {
  7.  private AccountDao accountDao = new AccountDaoImpl();
  9.  public void  saveAccount(){
  10.         accountDao.saveAccount();
  11.  }
  12. }

替代了

1561866927791

applicationContext.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.  xmlns:context="http://www.springframework.org/schema/context"
  5.  xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         http://www.springframework.org/schema/beans/spring-beans.xsd
  7.         http://www.springframework.org/schema/context
  8.         http://www.springframework.org/schema/context/spring-context.xsd">
  9. <!--注意约束新增了context-->
  10. <!--告知spring在创建容器时要扫描的包，配置所需要的标签不是在beans的约束中，而是一个名称为
  11. context名称空间和约束中-->
  12. <context:component-scan base-package="com.it"></context:component-scan>
  13. </beans>

注解配置-依赖注入 DI

用于注入数据的

​ 它们的作用就和在xml配置文件中的bean标签中写一个标签的作用是一样的

​ @Autowired: 
​ 基于spring 
作用：

  • 自动按照类型注入。只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功

  • 如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错。

  • 如果Ioc容器中有多个类型匹配时： 
    先按照类型匹配，如果不能匹配上，会按照属性的名称进行匹配

出现位置： 
可以是变量上，也可以是set方法上

细节： 
在使用注解注入时，set方法就不是必须的了。

​ @Qualifier: 
​ 配合@Autowired注解一起使用

​ 作用：在按照类型注入的基础之上再按照名称注入。

​ 属性： 
​ value：用于指定注入bean的id。 
​

​ @Resource 
​ JSR-250标准（基于jdk）

​ 作用：直接按照bean的id名称注入。如果id属性不存在，可以再按照类型注入。它可以独立使用 
​

​ 属性： 
​ name：用于指定bean的id，如果指定name，只能按照bean的id注入，不能按照类型注入。 
​

注意： 
以上三个注入都只能注入其他bean类型的数据，而基本类型和String类型无法使用上述注解实现（使用@Value）。

@Value 
作用：用于注入基本类型和String类型的数据 
属性： 
value：用于指定数据的值。使用${表达式}可以读取配置文件（.properties文件）的信息

  1. @Value(value = "张三")
  2. private String name;
  3. @Value(value = "18")
  4. private Integer age;
  7. public void saveAccount() {
  8.  System.out.println("执行AccountServiceImpl的保存账号方法   name:"+name+"    age:"+age);
  9.     accountDao.saveAccount();
  10. }

1561867354896

  1. @Service("accountService")
  2. public class AccountServiceImpl implements AccountService {
  4.  @Autowired
  5.  @Qualifier("accountDao1")
  6.  //@Resource(name = "accountDao2")
  7.  private AccountDao accountDao;
  9.  public void  saveAccount(){
  10.         accountDao.saveAccount();
  11.  }
  12. }

替代了

1561867527473

注解配置-作用域

用于改变作用范围的

他们的作用就和在bean标签中使用scope属性实现的功能是一样的

​ @Scope 
​

  • 作用：用于指定bean的作用范围

  • 属性： 
    value：指定范围的取值。

常用取值：singleton prototype

  1. @Service("accountService")
  2. @Scope("prototype")
  3. public class AccountServiceImpl implements AccountService {
  5.  @Autowired
  6.  @Qualifier("accountDao1")
  7.  //@Resource(name = "accountDao2")
  8.  private AccountDao accountDao = null;
  10.  public AccountServiceImpl(){
  11.  System.out.println("构造方法...测试多例");
  12.  }
  14.  public void  saveAccount(){
  15.         accountDao.saveAccount();
  16.  }
  17. }

1561868018781

注解配置-初始化和销毁（单例）

配置AccountServiceImpl.java

  1. @Service("accountService")
  2. //@Scope("prototype")// 测试初始化和销毁，不能使用多例
  3. public class AccountServiceImpl implements AccountService {
  5.  @Autowired
  6.  @Qualifier("accountDao1")
  7.  //@Resource(name = "accountDao2")
  8.  private AccountDao accountDao = null;
  10.  public AccountServiceImpl(){
  11.  System.out.println("构造方法...");
  12.  }
  14.  @PostConstruct
  15.  public void  init(){
  16.  System.out.println("初始化方法执行了");
  17.  }
  19.  @PreDestroy
  20.  public void  destroy(){
  21.  System.out.println("销毁方法执行了");
  22.  }
  24.  public void  saveAccount(){
  25.         accountDao.saveAccount();
  26.  }
  27. }

等同于配置文件：

  1. <bean id="accountService" class="com.it.service.impl.AccountServiceImpl" init-method=”init” destory-method=”destory”> </bean>

使用spring的IoC的实现账户的CRUD

导入坐标，pom.xml

  1. <dependencies>
  2.  <dependency>
  3.  <groupId>org.springframework</groupId>
  4.  <artifactId>spring-context</artifactId>
  5.  <version>5.0.2.RELEASE</version>
  6.  </dependency>
  7.  <dependency>
  8.  <groupId>commons-dbutils</groupId>
  9.  <artifactId>commons-dbutils</artifactId>
  10.  <version>1.4</version>
  11.  </dependency>
  13.  <dependency>
  14.  <groupId>mysql</groupId>
  15.  <artifactId>mysql-connector-java</artifactId>
  16.  <version>5.1.6</version>
  17.  </dependency>
  19.  <dependency>
  20.  <groupId>c3p0</groupId>
  21.  <artifactId>c3p0</artifactId>
  22.  <version>0.9.1.2</version>
  23.  </dependency>
  25.  <dependency>
  26.  <groupId>junit</groupId>
  27.  <artifactId>junit</artifactId>
  28.  <version>4.12</version>
  29.  </dependency>
  30.  </dependencies>

创建数据库

  1. create table account(
  2.     id int primary key auto_increment,
  3.     name varchar(40),
  4.     money float
  5. )character set utf8 collate utf8_general_ci;
  7. insert into account(name,money) values('aaa',1000);
  8. insert into account(name,money) values('bbb',1000);
  9. insert into account(name,money) values('ccc',1000);

创建实体

  1. /**
  2. * 账户的实体类
  3. */
  4. public class Account implements Serializable {
  6.  private Integer id;
  7.  private String name;
  8.  private Float money;
  9. // set和get方法...
  10. }

创建接口AccountDao.java 
实现CRUD操作

  1. /**
  2. * 账户的持久层接口
  3. */
  4. public interface AccountDao {
  6.  /**
  7.      * 查询所有
  8.      * @return
  9.      */
  10.  List<Account> findAllAccount();
  12.  /**
  13.      * 查询一个
  14.      * @return
  15.      */
  16.  Account findAccountById(Integer accountId);
  18.  /**
  19.      * 保存
  20.      * @param account
  21.      */
  22.  void saveAccount(Account account);
  24.  /**
  25.      * 更新
  26.      * @param account
  27.      */
  28.  void updateAccount(Account account);
  30.  /**
  31.      * 删除
  32.      * @param acccountId
  33.      */
  34.  void deleteAccount(Integer acccountId);
  35. }

创建接口的实现类AccountDaoImpl.java

  1. /**
  2. * 账户的持久层实现类
  3. */
  4. public class AccountDaoImpl implements AccountDao {
  6.  private QueryRunner runner;
  8.  public void setRunner(QueryRunner runner) {
  9.  this.runner = runner;
  10.  }
  12.  public List<Account> findAllAccount() {
  13.  try{
  14.  return runner.query("select * from account",new BeanListHandler<Account>(Account.class));
  15.  }catch (Exception e) {
  16.  throw new RuntimeException(e);
  17.  }
  18.  }
  21.  public Account findAccountById(Integer accountId) {
  22.  try{
  23.  return runner.query("select * from account where id = ? ",new BeanHandler<Account>(Account.class),accountId);
  24.  }catch (Exception e) {
  25.  throw new RuntimeException(e);
  26.  }
  27.  }
  30.  public void saveAccount(Account account) {
  31.  try {
  32.             runner.update("insert into account(name,money)values(?,?)",account.getName(),account.getMoney());
  33.  } catch (SQLException e) {
  34.  throw new RuntimeException(e);
  35.  }
  37.  }
  40.  public void updateAccount(Account account) {
  41.  try{
  42.             runner.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
  43.  }catch (Exception e) {
  44.  throw new RuntimeException(e);
  45.  }
  46.  }
  49.  public void deleteAccount(Integer accountId) {
  50.  try{
  51.             runner.update("delete from account where id=?",accountId);
  52.  }catch (Exception e) {
  53.  throw new RuntimeException(e);
  54.  }
  55.  }
  56. }

创建接口AccountService.java

  1. /**
  2. * 账户的业务层接口
  3. */
  4. public interface AccountService {
  6.  /**
  7.      * 查询所有
  8.      * @return
  9.      */
  10.  List<Account> findAllAccount();
  12.  /**
  13.      * 查询一个
  14.      * @return
  15.      */
  16.  Account findAccountById(Integer accountId);
  18.  /**
  19.      * 保存
  20.      * @param account
  21.      */
  22.  void saveAccount(Account account);
  24.  /**
  25.      * 更新
  26.      * @param account
  27.      */
  28.  void updateAccount(Account account);
  30.  /**
  31.      * 删除
  32.      * @param acccountId
  33.      */
  34.  void deleteAccount(Integer acccountId);
  37. }

创建接口的实现类AccountServiceImpl.java

  1. /**
  2. * 账户的业务层实现类
  3. */
  4. public class AccountServiceImpl implements AccountService {
  6.  private AccountDao accountDao;
  8.  public void setAccountDao(AccountDao accountDao) {
  9.  this.accountDao = accountDao;
  10.  }
  13.  public List<Account> findAllAccount() {
  14.  return accountDao.findAllAccount();
  15.  }
  18.  public Account findAccountById(Integer accountId) {
  19.  return accountDao.findAccountById(accountId);
  20.  }
  23.  public void saveAccount(Account account) {
  24.         accountDao.saveAccount(account);
  25.  }
  28.  public void updateAccount(Account account) {
  29.         accountDao.updateAccount(account);
  30.  }
  33.  public void deleteAccount(Integer acccountId) {
  34.         accountDao.deleteAccount(acccountId);
  35.  }
  36. }

编写测试类com.it.test，AccountServiceTest.java

  1. /**
  2. * 使用Junit单元测试：测试我们的配置
  3. */
  4. public class AccountServiceTest {
  7.  @Test
  8.  public void testFindAll() {
  9.  ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
  10.  AccountService as = (AccountService) ac.getBean("accountService");
  11.  //3.执行方法
  12.  List<Account> accounts = as.findAllAccount();
  13.  for(Account account : accounts){
  14.  System.out.println(account);
  15.  }
  16.  }
  18.  @Test
  19.  public void testFindOne() {
  20.  ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
  21.  AccountService as = (AccountService) ac.getBean("accountService");
  22.  //3.执行方法
  23.  Account account = as.findAccountById(1);
  24.  System.out.println(account);
  25.  }
  27.  @Test
  28.  public void testSave() {
  29.  ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
  30.  AccountService as = (AccountService) ac.getBean("accountService");
  31.  Account account = new Account();
  32.         account.setName("test");
  33.         account.setMoney(12345f);
  34.  //3.执行方法
  35.         as.saveAccount(account);
  37.  }
  39.  @Test
  40.  public void testUpdate() {
  41.  ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
  42.  AccountService as = (AccountService) ac.getBean("accountService");
  43.  //3.执行方法
  44.  Account account = as.findAccountById(4);
  45.         account.setMoney(23456f);
  46.         as.updateAccount(account);
  47.  }
  49.  @Test
  50.  public void testDelete() {
  51.  ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
  52.  AccountService as = (AccountService) ac.getBean("accountService");
  53.  //3.执行方法
  54.         as.deleteAccount(4);
  55.  }
  56. }

编写applicationContext.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.  xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.         http://www.springframework.org/schema/beans/spring-beans.xsd">
  6.  <!-- 配置Service -->
  7.  <bean id="accountService" class="com.it.service.impl.AccountServiceImpl">
  8.  <!-- 注入dao -->
  9.  <property name="accountDao" ref="accountDao"></property>
  10.  </bean>
  12.  <!--配置Dao对象-->
  13.  <bean id="accountDao" class="com.it.dao.impl.AccountDaoImpl">
  14.  <!-- 注入QueryRunner -->
  15.  <property name="runner" ref="runner"></property>
  16.  </bean>
  18.  <!--配置QueryRunner，设置prototype为多例，表示每次调用都获取一个新的连接对象-->
  19.  <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
  20.  <!--注入数据源（构造方法）-->
  21.  <constructor-arg name="ds" ref="dataSource"></constructor-arg>
  22.  </bean>
  24.  <!-- 配置数据源 -->
  25.  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  26.  <!--连接数据库的必备信息-->
  27.  <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
  28.  <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/itcastspring"></property>
  29.  <property name="user" value="root"></property>
  30.  <property name="password" value="root"></property>
  31.  </bean>
  32. </beans>

添加jdbc.properties文件

这里，也可以使用spring的${}动态赋值表达式，读取属性文件

第一步：添加jdbc.properties文件

  1. jdbc.driver=com.mysql.jdbc.Driver
  2. jdbc.url=jdbc:mysql://localhost:3306/itcastspring
  3. jdbc.username=root
  4. jdbc.password=root

第二步：修改applicationContext.xml

  1. <beans xmlns="http://www.springframework.org/schema/beans"
  2.  xmlns:context="http://www.springframework.org/schema/context"
  3.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.  xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.         http://www.springframework.org/schema/beans/spring-beans.xsd
  6.         http://www.springframework.org/schema/context
  7.         http://www.springframework.org/schema/context/spring-context.xsd">
  9. <context:property-placeholder location="jdbc.properties"></context:property-placeholder>
  10.  <!-- 配置数据源 -->
  11.  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  12.  <!--连接数据库的必备信息-->
  13.  <property name="driverClass" value="${jdbc.driver}"></property>
  14.  <property name="jdbcUrl" value="${jdbc.url}"></property>
  15.  <property name="user" value="${jdbc.username}"></property>
  16.  <property name="password" value="${jdbc.password}"></property>
  17.  </bean>
  18. </beans>

使用import加载多个applicationContext.xml

让程序加载多个spring的配置文件，对spring的配置文件细分 
applicationContext.xml：加载第三方的配置（数据源、QueryRunner） 
applicationContext-dao.xml：加载自己创建的Dao对象 
applicationContext-service.xml：加载自己创建的Service对象 
applicationContext-redis.xml、applicationContext-mq.xml、applicationContext-mybatis.xml等

1561869226921

需要使用import加载 
在applicationContext.xml中添加：

  1. <!--加载其他spring的配置文件-->
  2. <import resource="classpath:applicationContext-service.xml"></import>
  3. <import resource="classpath:applicationContext-dao.xml"></import>

使用注解配置IOC

使用DBUtils对账号表实现CRUD

创建数据库

  1. create table account(
  2.     id int primary key auto_increment,
  3.     name varchar(40),
  4.     money float
  5. )character set utf8 collate utf8_general_ci;
  7. insert into account(name,money) values('aaa',1000);
  8. insert into account(name,money) values('bbb',1000);
  9. insert into account(name,money) values('ccc',1000);

接口的实现类AccountDaoImpl.java修改

  1. /**
  2. * 账户的持久层实现类
  3. */
  4. @Repository("accountDao")
  5. public class AccountDaoImpl implements AccountDao {
  7.  @Autowired
  8.  private QueryRunner runner;
  11.  public List<Account> findAllAccount() {
  12.  try{
  13.  return runner.query("select * from account",new BeanListHandler<Account>(Account.class));
  14.  }catch (Exception e) {
  15.  throw new RuntimeException(e);
  16.  }
  17.  }
  19.  public Account findAccountById(Integer accountId) {
  20.  try{
  21.  return runner.query("select * from account where id = ? ",new BeanHandler<Account>(Account.class),accountId);
  22.  }catch (Exception e) {
  23.  throw new RuntimeException(e);
  24.  }
  25.  }
  27.  public void saveAccount(Account account) {
  28.  try{
  29.             runner.update("insert into account(name,money)values(?,?)",account.getName(),account.getMoney());
  30.  }catch (Exception e) {
  31.  throw new RuntimeException(e);
  32.  }
  33.  }
  35.  public void updateAccount(Account account) {
  36.  try{
  37.             runner.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
  38.  }catch (Exception e) {
  39.  throw new RuntimeException(e);
  40.  }
  41.  }
  43.  public void deleteAccount(Integer accountId) {
  44.  try{
  45.             runner.update("delete from account where id=?",accountId);
  46.  }catch (Exception e) {
  47.  throw new RuntimeException(e);
  48.  }
  49.  }
  50. }

接口的实现类AccountServiceImpl.java修改

  1. /**
  2. * 账户的业务层实现类
  3. */
  4. @Service("accountService")
  5. public class AccountServiceImpl implements AccountService {
  7.  @Autowired
  8.  private AccountDao accountDao;
  10.  public List<Account> findAllAccount() {
  11.  return accountDao.findAllAccount();
  12.  }
  14.  public Account findAccountById(Integer accountId) {
  15.  return accountDao.findAccountById(accountId);
  16.  }
  18.  public void saveAccount(Account account) {
  19.         accountDao.saveAccount(account);
  20.  }
  22.  public void updateAccount(Account account) {
  23.         accountDao.updateAccount(account);
  24.  }
  26.  public void deleteAccount(Integer acccountId) {
  27.         accountDao.deleteAccount(acccountId);
  28.  }
  29. }

applicationContext.xml修改

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.  xmlns:context="http://www.springframework.org/schema/context"
  5.  xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.         http://www.springframework.org/schema/beans/spring-beans.xsd
  7.         http://www.springframework.org/schema/context
  8.         http://www.springframework.org/schema/context/spring-context.xsd">
  10.  <!-- 告知spring在创建容器时要扫描的包 -->
  11.  <context:component-scan base-package="com.it"></context:component-scan>
  12.  <!--配置QueryRunner-->
  13.  <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
  14.  <!--注入数据源-->
  15.  <constructor-arg name="ds" ref="dataSource"></constructor-arg>
  16.  </bean>
  18.  <!-- 配置数据源 -->
  19.  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  20.  <!--连接数据库的必备信息-->
  21.  <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
  22.  <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/itcastspring"></property>
  23.  <property name="user" value="root"></property>
  24.  <property name="password" value="root"></property>
  25.  </bean>
  26. </beans>

企业开发的时候：一般配置文件（xml）+注解混合使用

配置文件：

  • 第三方提供的对象（QueryRunner、C3P0），可以由配置文件XML完成
  • 自己创建的对象（Controller、Service、Dao、工具类Utils），可以由注解进行完成

使用spring的注解配置，去掉applicationContext.xml中所有配置

准备:

  • 导入Account.java
  • 导入AccountDao.java和AccountDaoImpl.java
  • 导入AccountService.java和AccountServiceImpl.java
  • 导入AccountServiceTest.java的测试类

@Configuration注解

创建包config，创建SpringConfiguration.java类

  1. @Configuration
  2. public class SpringConfiguration {
  4. }

表示该类是一个配置类，它的作用和applicationContext.xml是一样的

spring5中的新注解 
@Configuration 
作用：指定当前类是一个配置类，如同取代applicationContext.xml中的配置 
细节：当配置类作为AnnotationConfigApplicationContext对象创建时，该注解可以不写。

@ComponentScan注解

@ComponentScan

作用：用于通过注解指定spring在创建容器时要扫描的包

属性： 
value：它和basePackages的作用是一样的，都是用于指定创建容器时要扫描的包的范围。

我们使用此注解就等同于在xml中配置了:

  1. <context:component-scan base-package="com.it"></context:component-scan
  1. @Configuration
  2. @ComponentScan(value = {"com.it"})
  3. public class SpringConfiguration {
  5. }

@Bean注解

@Bean

作用：用于把当前方法的返回值作为bean对象存入spring的ioc容器中

属性: 
name:用于指定bean的id。当不写时，默认值是当前方法的名称

依赖注入细节：

我们使用注解配置方法时，如果方法有参数，spring框架会去容器中查找有没有可用的bean对象，如果有bean对象，将对象通过方法的形参注入到方法中使用。查找的方式和Autowired注解的作用是一样的

  1. @Configuration//
  2. @ComponentScan(value = {"com.it"})
  3. public class SpringConfiguration {
  5.  /**
  6.      * 用于创建一个QueryRunner对象
  7.      * @param dataSource
  8.      * @return
  9.      */
  10.  @Bean(name="runner")
  11.  @Scope("prototype")
  12.  public QueryRunner createQueryRunner(DataSource dataSource){
  13.  return new QueryRunner(dataSource);
  14.  }
  16.  /**
  17.      * 创建数据源对象
  18.      * @return
  19.      */
  20.  @Bean(name="ds")
  21.  public DataSource createDataSource(){
  22.  try {
  23.  ComboPooledDataSource ds = new ComboPooledDataSource();
  24.             ds.setDriverClass("com.mysql.jdbc.Driver");
  25.             ds.setJdbcUrl("jdbc:mysql://localhost:3306/itcastspring");
  26.             ds.setUser("root");
  27.             ds.setPassword("root");
  28.  return ds;
  29.  }catch (Exception e){
  30.  throw new RuntimeException(e);
  31.  }
  32.  }
  33. }

1561869741733

工厂AnnotationConfigApplicationContext.java

当配置类作为AnnotationConfigApplicationContext对象创建的参数时，@Configuration注解可以不写。

使用AccountServiceTest.java测试查询：

  1. public class AccountServiceTest {
  4.  @Test
  5.  public void testFindAll() {
  6.  ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
  7.  AccountService as = (AccountService)ac.getBean("accountService");
  8.  //3.执行方法
  9.  List<Account> accounts = as.findAllAccount();
  10.  for(Account account : accounts){
  11.  System.out.println(account);
  12.  }
  13.  }
  14. }

创建测试类QueryRunnerTest.java，测试QueryRunner是否是单例。

  1. /**
  2. * 测试queryrunner是否单例
  3. */
  4. public class QueryRunnerTest {
  6.  @Test
  7.  public void  testQueryRunner(){
  8.  //1.获取容易
  9.  ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
  10.  //2.获取queryRunner对象
  11.  QueryRunner runner = ac.getBean("runner",QueryRunner.class);
  12.  QueryRunner runner1 = ac.getBean("runner",QueryRunner.class);
  13.  System.out.println(runner == runner1);
  14.  }
  15. }

@Import注解

@Import 
作用：用于导入其他的配置类 
属性：

value：用于指定其他配置类的字节码。

当我们使用Import的注解之后，有Import注解的类就父配置类，而导入的都是子配置类

相当于applicationContext.xml中的

第一步：创建配置类，JdbcConfig.java

将配置都放置到JdbcConfig中

  1. public class JdbcConfig {
  3.  /**
  4.      * 用于创建一个QueryRunner对象
  5.      * @param dataSource
  6.      * @return
  7.      */
  8.  @Bean(name="runner")
  9.  @Scope("prototype")
  10.  public QueryRunner createQueryRunner(DataSource dataSource){
  11.  return new QueryRunner(dataSource);
  12.  }
  14.  /**
  15.      * 创建数据源对象
  16.      * @return
  17.      */
  18.  @Bean(name="ds")
  19.  public DataSource createDataSource(){
  20.  try {
  21.  ComboPooledDataSource ds = new ComboPooledDataSource();
  22.             ds.setDriverClass("com.mysql.jdbc.Driver");
  23.             ds.setJdbcUrl("jdbc:mysql://localhost:3306/itcastspring");
  24.             ds.setUser("root");
  25.             ds.setPassword("root");
  26.  return ds;
  27.  }catch (Exception e){
  28.  throw new RuntimeException(e);
  29.  }
  30.  }
  31. }

用SpringConfiguration.java引入JdbcConfig的配置

  1. //@Configuration
  2. @ComponentScan(value = {"com.it"})
  3. @Import(value= JdbcConfig.class)
  4. public class SpringConfiguration {
  6. }

@PropertySource注解

@PropertySource

作用：用于指定properties文件的位置

属性： 
value：指定文件的名称和路径。

关键字：classpath，表示类路径下

在resource下创建 jdbcConfig.properties文件

  1. jdbc.driver=com.mysql.jdbc.Driver
  2. jdbc.url=jdbc:mysql://localhost:3306/itcastspring
  3. jdbc.username=root
  4. jdbc.password=root

配置SpringConfiguration.java

  1. //@Configuration
  2. @ComponentScan(value = {"com.it"})
  3. @Import(value= JdbcConfig.class)
  4. @PropertySource("classpath:jdbcConfig.properties")
  5. public class SpringConfiguration {
  7. }

配置JdbcConfig.java

  1. **
  2. * 和spring连接数据库相关的配置类
  3. */
  4. public class JdbcConfig {
  6.  @Value("${jdbc.driver}")
  7.  private String driver;
  9.  @Value("${jdbc.url}")
  10.  private String url;
  12.  @Value("${jdbc.username}")
  13.  private String username;
  15.  @Value("${jdbc.password}")
  16.  private String password;
  18.  /**
  19.      * 用于创建一个QueryRunner对象
  20.      * @param dataSource
  21.      * @return
  22.      */
  23.  @Bean(name="runner")
  24.  @Scope("prototype")
  25.  public QueryRunner createQueryRunner(DataSource dataSource){
  26.  return new QueryRunner(dataSource);
  27.  }
  29.  /**
  30.      * 创建数据源对象
  31.      * @return
  32.      */
  33.  @Bean(name="ds")
  34.  public DataSource createDataSource(){
  35.  try {
  36.  ComboPooledDataSource ds = new ComboPooledDataSource();
  37. //            ds.setDriverClass("com.mysql.jdbc.Driver");
  38. //            ds.setJdbcUrl("jdbc:mysql://localhost:3306/itcastspring");
  39. //            ds.setUser("root");
  40. //            ds.setPassword("root");
  41.             ds.setDriverClass(driver);
  42.             ds.setJdbcUrl(url);
  43.             ds.setUser(username);
  44.             ds.setPassword(password);
  45.  return ds;
  46.  }catch (Exception e){
  47.  throw new RuntimeException(e);
  48.  }
  49.  }
  50. }

@Qualifier注解

作用：如果spring容器中出现了多个数据源类型，使用该注解指定注入的数据源。

修改JdbcConfig.java的配置。

  1. /**
  2. * 用于创建一个QueryRunner对象
  3. * @param dataSource
  4. * @return
  5. */
  6. @Bean(name="runner")
  7. @Scope("prototype")
  8. public QueryRunner createQueryRunner(@Qualifier(value = "ds2") DataSource dataSource){
  9.  return new QueryRunner(dataSource);
  10. }
  12. /**
  13. * 创建数据源对象
  14. * @return
  15. */
  16. @Bean(name="ds1")
  17. public DataSource createDataSource(){
  18.  try {
  19.  ComboPooledDataSource ds = new ComboPooledDataSource();
  20.         ds.setDriverClass(driver);
  21.         ds.setJdbcUrl("jdbc:mysql:///itcastspring");
  22.         ds.setUser(username);
  23.         ds.setPassword(password);
  24.  return ds;
  25.  }catch (Exception e){
  26.  throw new RuntimeException(e);
  27.  }
  28. }
  30. @Bean(name="ds2")
  31. public DataSource createDataSource2(){
  32.  try {
  33.  ComboPooledDataSource ds = new ComboPooledDataSource();
  34.         ds.setDriverClass(driver);
  35.         ds.setJdbcUrl("jdbc:mysql:///test");
  36.         ds.setUser(username);
  37.         ds.setPassword(password);
  38.  return ds;
  39.  }catch (Exception e){
  40.  throw new RuntimeException(e);
  41.  }
  42. }

为什么全注解开发呢？

因为springboot框架中的底层会体现，全注解的配置

使用spring整合Junit

什么是main方法？

main方法，应用程序的入口

2、什么是junit方法？

junit单元测试中，没有main方法也能执行

​ 因为junit集成了一个main方法

​ 该方法就会判断当前测试类中哪些方法有 @Test注解

​ junit就让有@Test注解的方法执行

3、junit方法测试spring的IOC和DI的问题？

junit不会管我们是否采用spring框架

​ 在执行测试方法时，junit根本不知道我们是不是使用了spring框架

​ 所以也就不会为我们读取配置文件（基于XML）、配置类（基于注解）、并创建spring核心容器

4、总结：

由以上三点可知

​ 当测试方法执行时，没有Ioc容器，就算写了Autowired注解，也无法实现注入

​ 但是如何通过junit加载Ioc容器（即srping容器）呢？

Spring整合junit

Spring整合junit的配置

导入spring整合junit的jar(坐标)

  1. <dependency>
  2.  <groupId>org.springframework</groupId>
  3.  <artifactId>spring-test</artifactId>
  4.  <version>5.0.2.RELEASE</version>
  5. </dependency>
  6. <dependency>
  7.  <groupId>junit</groupId>
  8.  <artifactId>junit</artifactId>
  9.  <version>4.12</version>
  10. </dependency>

  • 使用Junit提供的一个注解把原有的main方法替换了，替换成spring提供的

  • 使用：@Runwith，加载SpringJUnit4ClassRunner.class

  • 告知spring的运行器，spring和ioc创建是基于xml还是基于注解的，并且说明位置

  • 使用@ContextConfiguration

locations：指定xml文件的位置，加上classpath关键字，表示在类路径下

@ContextConfiguration(locations = **"classpath:applicationContext.xml"**)

classes：指定注解类所在地位置

@ContextConfiguration(classes = SpringConfiguration.**class**)

注意：当我们使用spring 5.x版本的时候，要求junit的jar必须是4.12及以上

  1. /**
  2. * 使用Junit单元测试：测试我们的配置
  3. * Spring整合junit的配置
  4.  *      1、导入spring整合junit的jar(坐标)
  5.  *      2、使用Junit提供的一个注解把原有的main方法替换了，替换成spring提供的
  6.  *          @Runwith
  7.  *      3、告知spring的运行器，spring和ioc创建是基于xml还是注解的，并且说明位置
  8.  *          @ContextConfiguration
  9.  *                  locations：指定xml文件的位置，加上classpath关键字，表示在类路径下
  10.  *                  classes：指定注解类所在地位置
  11. *
  12.  *   当我们使用spring 5.x版本的时候，要求junit的jar必须是4.12及以上
  13. */
  14. @RunWith(SpringJUnit4ClassRunner.class)
  15. @ContextConfiguration(classes = SpringConfiguration.class)
  16. public class AccountServiceTest {
  18.  @Autowired
  19.  private AccountService as;
  22.  @Test
  23.  public void testFindAll() {
  24.  //3.执行方法
  25.  List<Account> accounts = as.findAllAccount();
  26.  for(Account account : accounts){
  27.  System.out.println(account);
  28.  }
  29.  }
  30. }
posted @ 2019-06-30 13:00  不穿格子衫的徍爺  阅读(143)  评论(0)  编辑  收藏  举报