文章目录
spring_2 注解、整合 Junit
一、基于注解使用 spring 的 IOC
1、 注解的入门案例
(1) 导入坐标
<!--只需要spring-context-->
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.6.RELEASE</version>
</dependency>
</dependencies>
(2) 持久层接口及其实现类
/**
* 账户的持久层接口
*/
public interface IAccountDao {
/**
* 模拟保存账户
*/
void saveAccount();
}
/**
* 账户的持久层实现类
*/
@Repository("accountDao1")
public class AccountDaoImpl implements IAccountDao {
/**
* 模拟保存账户
*/
public void saveAccount() {
System.out.println("保存账户11111111111111");
}
}
(3) 业务层接口及其实现类
/**
* 业务层接口
*/
public interface IAccountService {
public void saveAccount();
}
/**
* 业务层接口实现类
*/
@Service(value = "accountService")
public class AccountServiceImpl implements IAccountService {
// @Autowired
// @Qualifier(value = "accountDao2")
@Resource(name = "accountDao1")
private IAccountDao accountDao;
@PostConstruct
private void init(){
System.out.println("初始化方法执行了...");
}
@PreDestroy
private void destory(){
System.out.println("销毁方法执行了...");
}
public void saveAccount(){
accountDao.saveAccount();
}
}
(4) 类路径下创建bean.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"
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">
<!--告知spring在创建容器时要扫描的包,它就会扫描这个包及其子包下的所有类上或接口上的注解。配置所需要的标签不是在beans的约束中,而是一个名称为context名称空间和约束中-->
<context:component-scan base-package="com.yzx"/>
</beans>
(5) 测试配置是否成功
/**
* 模拟一个表现层,用于调用业务层
*/
public class Client {
public static void main(String[] args) {
//1.获取核心容器对象
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//2.根据id获取Bean对象,两种方式。@Service(value = "accountService"),value就是id
//value不定义就默认值是当前类名,且首字母改小写accountServiceImpl
IAccountService as = (IAccountService) ac.getBean("accountService");
// System.out.println(as);
//
// IAccountDao adao = ac.getBean("accountDao", IAccountDao.class);
// System.out.println(adao);
as.saveAccount();
ac.close();
}
}
2、入门案例中的一些注解说明
(0) 曾经的XML配置:
<bean id="accountService" class="top.zoick.service.impl.AccountServiceImpl">
scope="" init-method="" destroy-method="">
<property name="" value="" | ref=""> </property>
</bean>
(1) 用于创建对象的
他们的作用就和在XML配置文件中编写一个标签实现的功能是一样的
相当于:
@Component:
作用:用于把当前类对象存入spring容器中
属性:
value:用于指定bean的id。当我们不写时,它的默认值是当前类名,且首字母改小写。
@Controller: 一般用在表现层
@Service: 一般用在业务层
@Repository: 一般用在持久层
以上三个注解他们的作用和属性与Component是一模一样。
他们三个是spring框架为我们提供明确的三层使用的注解,使我们的三层对象更加清晰
(2) 用于注入数据的
他们的作用就和在xml配置文件中的bean标签中写一个标签的作用是一样的
@Autowired:
作用: 自动按类型注入。只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配,就可以注入成功
如果ioc容器中没有任何bean的类型和要注入的变量类型匹配,则报错。
如果Ioc容器中有多个类型匹配时:参考@Qualifier
出现位置:
可以是变量上,也可以是方法上
细节:
在使用注解注入时,set方法就不是必须的了。
@service("accountService")
public class AccountServiceImpl implements IAccountService {
@Autowired//根据IAccountDao前往springioc容器中找对应类型,然后注入到这么变量中来,从而使变量accountDao有值
private IAccountDao accountDao;// private IAccountDao accountDao = null;
// ....
}
@Qualifier:
作用: 在按照类中注入的基础之上再按照名称注入。它在给类成员注入时不能单独使用,必须和 @Autowired
一起使用。但是在给方法参数注入时可以(后面会写)
属性:
value:用于指定注入bean的id。
@service("accountService")
public class AccountServiceImpl implements IAccountService {
@Autowired
@Qualifier("accountDao1")
private IAccountDao accountDao;
// ...
}
@Resource:
作用: 直接按照bean的id注入。它可以独立使用
属性:
name: 用于指定bean的id。
import javax.annotation.Resource;
@service("accountService")
public class AccountServiceImpl implements IAccountService {
// @Autowired
// @Qualifier("accountDao")
@Resource(name = "accountDao")
private IAccountDao accountDao;
// ...
}
以上三个注入都只能注入其他bean类型的数据,而基本类型和String类型无法使用上述注解实现。
另外,集合类型的注入只能通过XML来实现。
@Value:
作用: 用于注入基本类型和String类型的数据
属性:
value:用于指定数据的值。它可以使用spring中SpEL(也就是spring的el表达式)
SpEL的写法:${表达式}
(3) 用于改变作用范围的
他们的作用就和在bean标签中使用scope属性实现的功能是一样的
相当于:
Scope:
作用: 用于指定bean的作用范围
属性:
value:指定范围的取值。常用取值:singleton
,prototype
(单例多例)
如@scope("prototype")
(4) 和生命周期相关
他们的作用就和在bean标签中使用init-method
和destroy-methode
的作用是一样的
相当于:
PreDestroy:
作用:用于指定销毁方法
PostConstruct:
作用:用于指定初始化方法
二、使用 spring 的 IOC 的实现账户的CRUD (XML配置)
1、相关案例
框架结构
和上基本差不多
(1) 导入坐标
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<dependency>
<groupId>commons-dbutils</groupId>
<artifactId>commons-dbutils</artifactId>
<version>1.4</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.15</version>
</dependency>
<!--c3p0连接池-->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.2</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.4</version>
</dependency>
</dependencies>
(2) 创建数据库和编写实体类
create table account(
id int primary key auto_increment,
name varchar(40),
money float
)character set utf8 collate utf8_general_ci;
insert into account(name,money) values('aaa',1000);
insert into account(name,money) values('bbb',1000);
insert into account(name,money) values('ccc',1000);
public class Account implements Serializable {
private Integer id;
private String name;
private Float money;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Double getBalance() {
return balance;
}
public void setBalance(Double balance) {
this.balance = balance;
}
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", balance=" + balance +
'}';
}
}
(3) 持久层接口及其实现类
/**
* @author zoick
* @date 2019/7/30 19:51
*/
public interface IAccountDao {
/**
* 查询所有
* @return
*/
List<Account> findAllAccount();
/**
* 查询一个
* @param accountId
* @return
*/
Account findAccountByID(Integer accountId);
/**
* 保存
* @param account
*/
void saveAccount(Account account);
/**
* 更新
* @param account
*/
void updateAccount(Account account);
/**
* 删除
* @param accountId
*/
void deleteAccount(Integer accountId);
}
public class AccountDaoImpl implements IAccountDao {
private QueryRunner runner;
public void setRunner(QueryRunner runner) {
this.runner = runner;
}
@Override
public List<Account> findAllAccount() {
try{
return runner.query("select * from account",new BeanListHandler<Account>(Account.class));
}catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
public Account findAccountByID(Integer accountId) {
try{
return runner.query("select * from account where id = ? ",new BeanHandler<Account>(Account.class),accountId);
}catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
public void saveAccount(Account account) {
try{
runner.update("insert into account(name,money)values(?,?)",account.getName(),account.getMoney());
}catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
public void updateAccount(Account account) {
try{
runner.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
}catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
public void deleteAccount(Integer accountId) {
try{
runner.update("delete from account where id=?",accountId);
}catch (Exception e) {
throw new RuntimeException(e);
}
}
}
(4) 业务层接口及其实现类
/**
* 账户的业务层接口
* @author zoick
* @date 2019/7/30 19:38
*/
public interface IAccountService {
/**
* 查询所有
* @return
*/
List<Account> findAllAccount();
/**
* 查询一个
* @param accountId
* @return
*/
Account findAccountByID(Integer accountId);
/**
* 保存
* @param account
*/
void saveAccount(Account account);
/**
* 更新
* @param account
*/
void updateAccount(Account account);
/**
* 删除
* @param accountId
*/
void deleteAccount(Integer accountId);
}
//账户的业务层实现类
public class AccountServiceImpl implements IAccountService {
private IAccountDao accountDao;
public void setAccountDao(IAccountDao accountDao) {
this.accountDao = accountDao;
}
/**
* 查询所有
*
* @return
*/
@Override
public List<Account> findAllAccount() {
return accountDao.findAllAccount();
}
/**
* 查询一个
*
* @param accountId
* @return
*/
@Override
public Account findAccountByID(Integer accountId) {
return accountDao.findAccountByID(accountId);
}
/**
* 保存
*
* @param account
*/
@Override
public void saveAccount(Account account) {
accountDao.saveAccount(account);
}
/**
* 更新
*
* @param account
*/
@Override
public void updateAccount(Account account) {
accountDao.updateAccount(account);
}
/**
* 删除
*
* @param accountId
*/
@Override
public void deleteAccount(Integer accountId) {
accountDao.deleteAccount(accountId);
}
}
(4) bean.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">
<!--配置Service-->
<bean id="accountService" class="top.zoick.service.impl.AccountServiceImpl">
<!--注入dao-->
<property name="accountDao" ref="accountDao"></property>
</bean>
<!--配置dao对象-->
<bean id="accountDao" class="top.zoick.dao.impl.AccountDaoImpl">
<!--注入QueryRunner-->
<property name="runner" ref="runner"></property>
</bean>
<!--配置QueryRunner-->
<bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
<!--注入数据源-->
<constructor-arg name="ds" ref="dataSource" ></constructor-arg>
</bean>
<!--配置数据源-->
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!--连接数据库的必备信息-->
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/eesy"></property>
<property name="user" value="root"></property>
<property name="password" value="root"></property>
</bean>
</beans>
(5) 测试
/**
* 使用Junit单元测试:测试我们的配置
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountServiceTest {
@Autowired
private IAccountService as;
@Test
public void testFindAll() {
//1.获取容器
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//2.得到业务层对象
IAccountService as = ac.getBean("accountService", IAccountService.class);
//3.执行方法
List<Account> accounts = as.findAllAccount();
for(Account account : accounts){
System.out.println(account);
}
}
@Test
public void testFindOne() {
//1.获取容器
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//2.得到业务层对象
IAccountService as = ac.getBean("accountService", IAccountService.class);
//3.执行方法
Account account = as.findAccountByID(1);
System.out.println(account);
}
@Test
public void testSave() {
Account account = new Account();
account.setName("test");
account.setMoney(12345f);
//1.获取容器
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//2.得到业务层对象
IAccountService as = ac.getBean("accountService", IAccountService.class);
//3.执行方法
as.saveAccount(account);
}
@Test
public void testUpdate() {
//1.获取容器
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//2.得到业务层对象
IAccountService as = ac.getBean("accountService", IAccountService.class);
//3.执行方法
Account account = as.findAccountByID(4);
account.setMoney(23456f);
as.updateAccount(account);
}
@Test
public void testDelete() {
//1.获取容器
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//2.得到业务层对象
IAccountService as = ac.getBean("accountService", IAccountService.class);
//3.执行方法
as.deleteAccount(4);
}
}
2、 半注解(XML + 注解)方式
如果想使用注解进行配置,那么就可以用到上述注解
- 业务层代码
@Service("accountService")
public class AccountServiceImpl implements IAccountService {
@Autowired
private IAccountDao accountDao;
// 不需要 set 方法...
// 业务方法省略...
}
- 持久层代码
@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {
@Autowired
private QueryRunner runner;
// 不需要 set 方法...
// 持久化方法省略...
}
- 配置文件
<?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
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="cn.ykf"></context:component-scan>
<!-- 配置QueryRunner -->
<bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
<!-- 注入数据源 -->
<constructor-arg name="ds" ref="dataSource"></constructor-arg>
</bean>
<!-- 配置数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/db_demo"></property>
<property name="user" value="root"></property>
<property name="password" value="773620096zxc"></property>
</bean>
</beans>
无法在
QueryRunner
和ComboPooledDataSource
等第三方类上加注解,所以还是需要配置文件。
三、账户的CRUD ( 纯注解无XML)
1、相关案例
(1) 无xml纯注解配置思路
使用配置类来配置bean.xml中的相关配置
(2) 待改造的问题
我们发现,之所以我们现在离不开 xml 配置文件,是因为我们有一句很关键的配置:
<!-- 告知spring框架在,读取配置文件,创建容器时,扫描注解,依据注解创建对象,并存入容器中 -->
<context:component-scan base-package="com.itheima"></context:component-scan>
如果他要也能用注解配置,那么我们就离脱离 xml 文件又进了一步。
另外,数据源和 QueryRunner 的配置也需要靠注解来实现。
<!--配置QueryRunner-->
<bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
<!--注入数据源-->
<constructor-arg name="ds" ref="dataSource" ></constructor-arg>
</bean>
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!--连接数据库的必备信息-->
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/eesy"></property>
<property name="user" value="root"></property>
<property name="password" value="root"></property>
</bean>
(3) 新注解说明
@Configuration
作用:
用于指定当前类是一个 spring 配置类,它的作用和bean.xml一样,当创建容器时会从该类上加载注解。获取容器时需要使用
AnnotationApplicationContext(有@Configuration 注解的类.class)。
属性:
value: 用于指定配置类的字节码
示例:
@Configuration
public class SpringConfiguration {
}
注意:
已经把配置文件用类来代替了,但是如何配置创建容器时要扫描的包呢?
请看下一个注解 @ComponentScan。
@ComponentScan
作用:
用于指定 spring 在初始化(创建)容器时要扫描的包。作用和在 spring 的 xml 配置文件中的:
<context:component-scan base-package="com.itheima"></context:component-scan
>是一样的。
属性:
basePackages:用于指定要扫描的包。和该注解中的 value 属性作用一样。
示例:
@Configuration
@ComponentScan(basePackages = {"com.itheima"})//这是标准写法,如果注解属性有且只有一个值,数组类型可以省略{},且前面的value也可省略。
//@ComponentScan("com.itheima")
public class SpringConfiguration {
}
注意:
我们已经配置好了要扫描的包,但是数据源和 Runner 对象如何从配置文件中移除呢?
请看下一个注解 @Bean。
@Bean
作用:
该注解只能写在方法上,表明使用此方法创建一个对象(把当前方法的返回值作为bean对象存入spring ioc容器中),并且放入 spring 容器。
属性:
name:用于指定bean的id,也就是给当前@Bean 注解方法创建的对象指定一个名称(即 bean 的 id),默认值是当前方法名称。id对应ioc(map结构)容器中的key,创建的对象就是value
对应bean.xml中
<bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
示例:
/**
* 和spring连接数据库相关的配置类
*/
//@Configuration //当配置类作为AnnotationConfigApplicationContext对象创建的参数时,该注解可以不写。但是后面test时并没有将其作为参数,故此处不可省略
public class JdbcConfig {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String username;
@Value("${jdbc.password}")
private String password;
/**
* 用于创建一个QueryRunner对象也存入容器中
* @param dataSource
* @return
*/
@Bean(name = "ruuner")
@Scope("prototype")
public QueryRunner createQueryRunner(DataSource dataSource){
return new QueryRunner(dataSource);
}
/**
* 创建数据源对象并存入spring容器中
* @return
*/
@Bean(name = "dataSource")
public DataSource createDataSource() {
try {
ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setDriverClass("com.mysql.cj.jdbc.Driver");
ds.setJdbcUrl("jdbc:mysql://localhost:3306/eesy");
ds.setUser("root");
ds.setPassword("root");
return ds;
} catch (PropertyVetoException e) {
throw new RuntimeException(e);
}
}
@Bean(name="ds1")
public DataSource createDataSource1(){
try {
ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setDriverClass(driver);
ds.setJdbcUrl("jdbc:mysql://localhost:3306/eesy02");
ds.setUser(username);
ds.setPassword(password);
return ds;
}catch (Exception e){
throw new RuntimeException(e);
}
}
}
注意:
我们已经把数据源和 Runner 从配置文件中移除了,此时可以删除 bean.xml 了。
但是由于没有了配置文件,创建数据源的配置又都写死在类中了。如何把它们配置出来呢?
请看下一个注解 @PropertySource。
@PropertySource
作用:
用于加载.properties 文件中的配置。例如我们配置数据源时,可以把连接数据库的信息写到
properties 配置文件中,就可以使用此注解指定 properties 配置文件的位置。
属性:
value[]:用于指定 properties 文件位置。如果是在类路径下,需要写上 classpath:
示例:
上一个示例已经使用了,这个注解写在主配置文件上
jdbc.properties 文件:
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/eesy
jdbc.username=root
jdbc.password=root
注意:
此时我们已经有了两个配置类,但是他们还没有关系。如何建立他们的关系呢?
请看下一个注解 @Import。
@Import
作用:
用于导入其他配置类,在引入其他配置类时,可以不用再写@Configuration 注解。写上也没问题。
属性:
value[]:用于指定其他配置类的字节码。
@Configuration
@ComponentScan(basePackages = {"top.zoick"})
@Import(JdbcConfig.class)
@PropertySource("classpath:jdbcConfig.properties")
public class SpringConfiguration {
}
注意:
我们已经把要配置的都配置好了,但是新的问题产生了,由于没有配置文件了,如何获取容器呢?
请看下一小节。
(4) 通过注解获取容器
ApplicationContext ac =
new AnnotationConfigApplicationContext(SpringConfiguration.class);
2、Spring 整合 Junit
(1) 问题
在测试类中,每个测试方法都有以下两行代码:
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
IAccountService as = ac.getBean("accountService",IAccountService.class);
这两行代码的作用是获取容器,如果不写的话,直接会提示空指针异常。所以又不能轻易删掉。
(2) 解决思路分析
针对上述问题,我们需要的是程序能自动帮我们创建容器。一旦程序能自动为我们创建 spring 容器,就
无须手动创建了,问题也就解决了。
这时,我们需要依靠 spring 框架,因为它提供了一个运行器,可以读取配置文件(或注解)来创建容器。我
们只需要告诉它配置文件在哪就行了。
我们是测试类,应该专注于测试功能,所以需要程序可以帮我们自己创建容器并且注入 service 对象。这时候就需要使用Spring 来整合 JUnit,步骤如下
(3) 步骤
a、导入spring-test依赖
<!-- 导入spring整合junit的jar(坐标)
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
b、使用junit提供的@RunWith 注解替换原有运行器(main方法),换成spring提供的
@RunWith(SpringJUnit4ClassRunner.class)
public class IAccountServiceTest {
// ....
}
c、使用@ContextConfiguration 指定 spring 配置文件的位置
@ContextConfiguration 注解:
locations 属性:用于指定配置文件的位置。如果是类路径下,需要用 classpath:表明
classes 属性:用于指定注解的类。当不使用 xml 配置时,需要用此属性指定注解类的位置。
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class AccountServiceTest {
@Autowired
private IAccountService as;
@Test
public void testFindAll() {
//3.执行方法
List<Account> accounts = as.findAllAccount();
for(Account account : accounts){
System.out.println(account);
}
}
}