之前的 XML 配置：
<bean id="accountService" class="cn.parzulpan.service.AccountServiceImpl"
scope="" init-method="" destroy-method=""
<perperty name="" value="" | ref=""/>
/>
常用注解的分类：
<bean id="" class=""> 标签实现的功能相同。<bean> 标签中写一个 <perperty> 标签实现的功能相同。<bean> 标签中 scope 属性实现的功能相同。<bean> 标签中 init-method 和 destroy-method 属性实现的功能相同。<bean id="" class=""> 标签实现的功能相同。
@Component 用于把当前类对象存入 Spring 容器中，value 属性 指定 bean 的 id，如果不指定 value 属性，默认 bean 的 id 是当前类的类名，首字母小写。@Controller 一般用于表现层的注解。@Service 一般用于业务层的注解。@Repository 一般用于持久层的注解。注意：如果注解中有且只有一个属性要赋值时，且名称是 value，value 在赋值是可以不写。
package cn.parzulpan.service;
import org.springframework.stereotype.Component;
/**
* @Author : parzulpan
* @Time : 2020-12
* @Desc :
*/
@Component()
public class AccountServiceImpl implements AccountService {
}
package cn.parzulpan.ui;
import cn.parzulpan.service.AccountService;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @Author : parzulpan
* @Time : 2020-12
* @Desc :
*/
public class Client {
public static void main(String[] args) {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
AccountService as = ac.getBean("accountServiceImpl", AccountService.class);
System.out.println(as);
}
}
注意：由于用到了注解，所以需要配置 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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!-- 告知 Spring 在创建容器时要扫描的包 -->
<context:component-scan base-package="cn.parzulpan"></context:component-scan>
</beans>
<bean> 标签中写一个 <perperty> 标签实现的功能相同。
@Autowired 自动按照类型注入。当使用注解注入属性时，set 方法可以省略。它只能注入其他 bean 类型，当有多个类型匹配时，使用要注入的对象变量名称作为 bean 的 id，在 spring 容器查找，找到了也可以注入成功，找不到就报错。@Qualifier 在自动按照类型注入的基础之上，再按照 Bean 的 id 注入。它在给成员注入时不能独立使用，必须和 @Autowire 一起使用；但是给方法参数注入时，可以独立使用。它也只能注入其他 bean 类型。value 属性 指定 bean 的 id。@Resource 直接按照 Bean 的 id 注入，能独立使用。它也只能注入其他 bean 类型。name 属性 指定 bean 的 id。@Value 注入基本数据类型和 String 类型数据。value属性 用于指定值，它也可以使用 Spring 的 SpEL，即 Spring 的 EL 表达式（${表达式}）。package cn.parzulpan.service;
import cn.parzulpan.dao.AccountDAO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @Author : parzulpan
* @Time : 2020-12
* @Desc :
*/
@Service
public class AccountServiceImpl implements AccountService {
// @Autowired
// private AccountDAO accountDAO;
// @Autowired
// @Qualifier("accountDAOImpl2")
// private AccountDAO accountDAO;
@Resource(name = "accountDAOImpl2")
private AccountDAO accountDAO;
@Override
public void saveAccount() {
System.out.println(accountDAO);
accountDAO.saveAccount();
}
}
注意：集合类型的注入只能通过 XML 来实现。
<bean> 标签中 scope 属性实现的功能相同。
value 属性 指定范围的值。取值为 singleton prototype request session globalsession@Scope("prototype")
public class AccountServiceImpl implements AccountService {}
<bean> 标签中 init-method 和 destroy-method 属性实现的功能相同。
@PostConstruct 用于指定初始化方法。@PreDestroy 用于指定销毁方法。@Service
@Scope("singleton")
public class AccountServiceImpl implements AccountService {
@PostConstruct
public void init() {
System.out.println("AccountService 对象初始化...");
}
@PreDestroy
public void destroy() {
System.out.println("AccountService 对象销毁...");
}
}
需求：实现银行账户的 CRUD 操作。采用 xml 配置。使用 Spring IOC 实现对象的管理，使用 DBUtils 和 C3P0 作为持久层解决方案。小节源码
银行账户表结构
use springT;
# ---
# 银行账户表结构
drop table if exists `bankAccount`;
create table `bankAccount`(
`id` int(11) primary key auto_increment,
`name` varchar(32) not null comment ‘账户名称‘,
`money` float not null comment ‘账户余额‘
) engine=InnoDB default charset=utf8;
insert into bankAccount(name, money) values
(‘aaa‘, 1000), (‘bbb‘, 2000), (‘ccc‘, 3000);
# ---
银行账户的实体类
package cn.parzulpan.domain;
import java.io.Serializable;
/**
* @Author : parzulpan
* @Time : 2020-12
* @Desc : 银行账户的实体类
*/
public class BankAccount implements Serializable {
private Integer id;
private String name;
private Double money;
public BankAccount() {
}
public BankAccount(Integer id, String name, Double money) {
this.id = id;
this.name = name;
this.money = 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 getMoney() {
return money;
}
public void setMoney(Double money) {
this.money = money;
}
@Override
public String toString() {
return "BankAccount{" +
"id=" + id +
", name=‘" + name + ‘\‘‘ +
", money=" + money +
‘}‘;
}
}
银行账户的持久层接口的实现类
package cn.parzulpan.dao;
import cn.parzulpan.domain.BankAccount;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import java.sql.SQLException;
import java.util.List;
/**
* @Author : parzulpan
* @Time : 2020-12
* @Desc : 银行账户的持久层接口的实现类
*/
public class BankAccountDAOImpl implements BankAccountDAO {
private QueryRunner runner;
public void setRunner(QueryRunner runner) {
this.runner = runner;
}
public List<BankAccount> findAll() {
try {
return runner.query("select * from bankAccount",
new BeanListHandler<BankAccount>(BankAccount.class));
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
public BankAccount findById(Integer id) {
try {
return runner.query("select * from bankAccount where id = ?",
new BeanHandler<BankAccount>(BankAccount.class), id);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
public void save(BankAccount bankAccount) {
try {
runner.update("insert into bankAccount(name, money) values (?, ?)",
bankAccount.getName(), bankAccount.getMoney());
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
public void update(BankAccount bankAccount) {
try {
runner.update("update bankAccount set name = ?, money = ? where id = ?",
bankAccount.getName(), bankAccount.getMoney(), bankAccount.getId());
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
public void deleteById(Integer id) {
try {
runner.update("delete from bankAccount where id = ?",
id);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
银行账户的业务层接口的实现类
package cn.parzulpan.service;
import cn.parzulpan.dao.BankAccountDAO;
import cn.parzulpan.domain.BankAccount;
import java.util.List;
/**
* @Author : parzulpan
* @Time : 2020-12
* @Desc : 银行账户的业务层接口的实现类
*/
public class BankAccountServiceImpl implements BankAccountService {
private BankAccountDAO bankAccountDAO;
public void setBankAccountDAO(BankAccountDAO bankAccountDAO) {
this.bankAccountDAO = bankAccountDAO;
}
public List<BankAccount> findAll() {
return bankAccountDAO.findAll();
}
public BankAccount findById(Integer id) {
return bankAccountDAO.findById(id);
}
public void save(BankAccount bankAccount) {
bankAccountDAO.save(bankAccount);
}
public void update(BankAccount bankAccount) {
bankAccountDAO.update(bankAccount);
}
public void deleteById(Integer id) {
bankAccountDAO.deleteById(id);
}
}
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="bankAccountService" class="cn.parzulpan.service.BankAccountServiceImpl">
<!-- 注入DAO，set() 形式-->
<property name="bankAccountDAO" ref="bankAccountDAO"/>
</bean>
<!-- 配置 DAO -->
<bean id="bankAccountDAO" class="cn.parzulpan.dao.BankAccountDAOImpl">
<!-- 注入QueryRunner，set() 形式-->
<property name="runner" ref="runner"/>
</bean>
<!-- 配置 QueryRunner -->
<bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
<!-- 注入数据源，构造函数形式-->
<constructor-arg name="ds" ref="dataSource"/>
</bean>
<!-- 配置 数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/springT?useSSL=false"/>
<property name="user" value="root"/>
<property name="password" value="root"/>
</bean>
</beans>
对银行账户的业务层接口的实现类进行单元测试
package cn.parzulpan.service;
import cn.parzulpan.domain.BankAccount;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;
/**
* @Author : parzulpan
* @Time : 2020-12
* @Desc : 对银行账户的业务层接口的实现类进行单元测试
* 可以看到，每个测试方法都重新获取了一次 Spring 的核心容器，造成了不必要的重复代码，这个问题可以整合 Junit 解决
*/
public class BankAccountServiceImplTest {
@Test
public void findAll() {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
BankAccountService as = ac.getBean("bankAccountService", BankAccountService.class);
List<BankAccount> accounts = as.findAll();
for (BankAccount account : accounts) {
System.out.println(account);
}
}
@Test
public void findById() {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
BankAccountService as = ac.getBean("bankAccountService", BankAccountService.class);
BankAccount account = as.findById(1);
System.out.println(account);
}
@Test
public void save() {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
BankAccountService as = ac.getBean("bankAccountService", BankAccountService.class);
as.save(new BankAccount(null, "ta", 4325.12314));
}
@Test
public void update() {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
BankAccountService as = ac.getBean("bankAccountService", BankAccountService.class);
BankAccount account = as.findById(1);
account.setMoney(5153.325);
as.update(account);
}
@Test
public void deleteById() {
ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
BankAccountService as = ac.getBean("bankAccountService", BankAccountService.class);
as.deleteById(4);
}
}
由于 xml 文件中，依然需要告知 Spring 在创建容器时要扫描的包，以及配置数据源等。
现在是如何用注解替代这些配置。
新注解：
@Configuration 指定当前类是一个 Spring 配置类。value 属性 用于指定配置类的字节码。@ComponentScan 指定 Spring 在初始化容器时要扫描的包。basePackages/value 属性 用于指定要扫描的包。@Bean 该注解只能写在方法上，表明使用此方法创建一个对象，并且放入 Spring 容器。name 属性 给当前 @Bean 注解方法创建的对象指定一个名称（即 bean 的 id）。@PropertySource 用于加载 .properties 文件中的配置。value[] 属性 用于指定 properties 文件位置。如果是在类路径下，需要写上 classpath。@Import 用于导入其他配置类，在引入其他配置类时，可以不用再写 @Configuration 注解，但是建议写上。value[] 属性 用于指定其他配置类的字节码。public class AccountServiceTest {
@Autowired
private AccountService as;
@Test
public void findAllTest() {
as.findAllAccount(); // nullPointerExcepetion
}
}
在 Junit 中：
main()，但是在 Junit 中，没有 main() 也能运行，因为 Junit 集成了一个 main()，该方法会判断当前测试类中哪些方法有 @Test 注解，然后让其执行@Autowired 注解，也无法实现注入但是 Junit 给暴露了一个注解，可以替换掉它的运行器（ 替换 main() ）。这时，需要依靠 Spring 框架，因为它提供了一个运行器，可以读取配置文件（或注解）来创建容器。只需要告诉它配置文件在哪就行了。
@RunWith 替换 main 方法@ContextConfiguration 告知 Spring 的运行其，Spring IOC 创建是基于 xml 还是 注解的，并且说明文字。locations 属性 用于指定配置文件的位置。如果是类路径下，需要用 classpath: 表明。classes 属性 用于指定注解的类。当不使用 xml 配置时，需要用此属性指定注解类的位置。需求：实现银行账户的 CRUD 操作。采用 annotation 配置。使用 Spring IOC 实现对象的管理，使用 DBUtils 和 C3P0 作为持久层解决方案。小节源码
银行账户的持久层接口的实现类，添加注入数据
@Repository("bankAccountDAO")
public class BankAccountDAOImpl implements BankAccountDAO {
@Autowired
private QueryRunner runner;
}
银行账户的业务层接口的实现类，添加注入数据
@Service("bankAccountService")
public class BankAccountServiceImpl implements BankAccountService {
@Autowired
private BankAccountDAO bankAccountDAO;
}
连接数据库的配置类
package cn.parzulpan.config;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.annotation.Scope;
import javax.sql.DataSource;
import java.beans.PropertyVetoException;
/**
* @Author : parzulpan
* @Time : 2020-12
* @Desc : 连接数据库的配置类，代替 配置 QueryRunner 和 配置 数据源，并且导入数据库的配置文件
*
* <!-- 配置 QueryRunner -->
* <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
* <!-- 注入数据源，构造函数形式-->
* <constructor-arg name="ds" ref="dataSource"/>
* </bean>
*
* <!-- 配置 数据源 -->
* <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
* <property name="driverClass" value="com.mysql.jdbc.Driver"/>
* <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/springT?useSSL=false"/>
* <property name="user" value="root"/>
* <property name="password" value="root"/>
* </bean>
*
*/
@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {
@Value("${jdbc.driver}")
private String driverClass;
@Value("${jdbc.url}")
private String jdbcUrl;
@Value("${jdbc.username}")
private String user;
@Value("${jdbc.password}")
private String password;
/**
* 创建 QueryRunner，使用 数据源 1
* @param dataSource
* @return
*/
@Bean(name = "runner")
@Scope("prototype")
public QueryRunner createQueryRunner(@Qualifier("dataSource1") DataSource dataSource) {
return new QueryRunner(dataSource);
}
/**
* 创建 数据源 1
* @return
*/
@Bean(name = "dataSource1")
public DataSource createDataSource1() {
try {
ComboPooledDataSource ds = new ComboPooledDataSource();
ds.setDriverClass(driverClass);
ds.setJdbcUrl(jdbcUrl);
ds.setUser(user);
ds.setPassword(password);
return ds;
} catch (PropertyVetoException e) {
throw new RuntimeException(e);
}
}
/**
* 创建 数据源 2
* @return
*/
@Bean(name = "dataSource2")
public DataSource createDataSource2() {
try {
ComboPooledDataSource ds2 = new ComboPooledDataSource();
ds2.setDriverClass(driverClass);
ds2.setJdbcUrl(jdbcUrl);
ds2.setUser(user);
ds2.setPassword(password);
return ds2;
} catch (PropertyVetoException e) {
throw new RuntimeException(e);
}
}
}
Spring 的配置类
package cn.parzulpan.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;
/**
* @Author : parzulpan
* @Time : 2020-12
* @Desc : Spring 的配置类，作用和 bean.xml 相同，并且导入连接数据库的配置类
*
* <!-- 告知 Spring 在创建容器时要扫描的包 -->
* <context:component-scan base-package="cn.parzulpan"/>
*
*/
@Configuration
@ComponentScan("cn.parzulpan")
@Import(JdbcConfig.class)
public class SpringConfiguration {
}
对银行账户的业务层接口的实现类进行单元测试，整合 Junit 解决重复代码问题，使用注解
package cn.parzulpan.service;
import cn.parzulpan.config.SpringConfiguration;
import cn.parzulpan.domain.BankAccount;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
/**
* @Author : parzulpan
* @Time : 2020-12
* @Desc : 对银行账户的业务层接口的实现类进行单元测试，整合 Junit 解决重复代码问题，使用注解
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class BankAccountServiceImplAndJunitTest {
@Autowired
private BankAccountService as;
@Test
public void findAll() {
// 通过注解获取容器
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
BankAccountService as = ac.getBean("bankAccountService", BankAccountService.class);
List<BankAccount> accounts = as.findAll();
for (BankAccount account : accounts) {
System.out.println(account);
}
}
@Test
public void findById() {
// 整合 Junit
BankAccount account = as.findById(1);
System.out.println(account);
}
@Test
public void save() {
// 整合 Junit
as.save(new BankAccount(null, "ta", 4325.12314));
}
@Test
public void update() {
// 整合 Junit
BankAccount account = as.findById(1);
account.setMoney(5153.325);
as.update(account);
}
@Test
public void deleteById() {
// 整合 Junit
as.deleteById(4);
}
}
可以看到，纯注解开发实际上也比较繁琐，所以推荐混合开发。XML 配置 适用于 Bean 来自第三方实现，而 注解配置 适用于 Bean 来自自己实现。
原文：https://www.cnblogs.com/parzulpan/p/14168507.html