1、Spring配置数据源
1.1 数据源（连接池）的作用
-
数据源（连接池）是提高程序性能而出现的
-
事先实例化数据源，初始化部分链接资源
-
使用连接资源时从数据源中获取
-
使用完毕后将连接资源归还给数据源
常见的数据源：DBCP、C3P0、BoneCp、Druid等
开发步骤：
1、导入数据源的坐标和数据库驱动坐标
2、创建数据源对象
3、设置数据源的基本连接数据
4、使用数据源获取连接资源和归还连接资源
1.2 数据源的手动创建
1、导入mysql数据库驱动坐标、导入c3p0和druid的坐标
<dependencies>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>8.0.28version>
dependency>
<dependency>
<groupId>c3p0groupId>
<artifactId>c3p0artifactId>
<version>0.9.1.2version>
dependency>
<dependency>
<groupId>com.alibabagroupId>
<artifactId>druidartifactId>
<version>1.2.8version>
dependency>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.13.2version>
<scope>testscope>
dependency>
dependencies>
2、创建c3p0连接池
1 import com.mchange.v2.c3p0.ComboPooledDataSource;
2 import org.junit.Test;
3
4 import java.sql.Connection;
5
6 public class DatasourceTest {
7 @Test
8 public void test1() throws Exception {
9 //创建数据源
10 ComboPooledDataSource dataSource = new ComboPooledDataSource();
11 //数据库连接参数
12 dataSource.setDriverClass("com.mysql.jdbc.Driver");
13 dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
14 dataSource.setUser("root");
15 dataSource.setPassword("123");
16 //获得连接对象
17 Connection conn = dataSource.getConnection();
18 System.out.println(conn);
19 conn.close();
20
21 }
22 }
jdbc.driver=com.mysql.jdbc.driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=123
4.读取配置文件创建连接池
1 @Test
2 //测试手动创建c3p0数据源（加载properties配置文件）
3 public void testC3p0Properties() throws Exception {
4 //加载配置文件 jdbc.properties
5 ResourceBundle rb = ResourceBundle.getBundle("jdbc");
6 ComboPooledDataSource dataSource = new ComboPooledDataSource();
7 dataSource.setDriverClass(rb.getString("jdbc.driver"));
8 dataSource.setJdbcUrl(rb.getString("jdbc.url"));
9 dataSource.setUser(rb.getString("jdbc.username"));
10 dataSource.setPassword(rb.getString("jdbc.password"));
11 Connection conn = dataSource.getConnection();
12 System.out.println(conn);
13 conn.close();
14 }
1.3 Spring配置数据源
可以将DataSource的创建权交由Spring容器去完成
<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/test">property>
<property name="user" value="root">property>
<property name="password" value="123">property>
bean>
测试从容器中获取数据源
1 @Test
2 //spring容器产生数据对象
3 public void testSpringDataSource() throws Exception {
4 ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
5 DataSource dataSource = app.getBean(DataSource.class);
6 Connection conn = dataSource.getConnection();
7 System.out.println(conn);
8 conn.close();
9 }
1.4 抽取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
加载外部的properties配置文件
<context:property-placeholder location="classpath:jdbc.properties"/>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driver}"/>
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
bean>
2.1 Spring原始注解
Spring是请代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，从而提高开发效率。
Spring原始注解主要是替代
| 注解 | 说明 |
|---|---|
| @Component | 使用在类上，用于实例化Bean |
| @Controller | 使用在web层类上，用于实例化Bean |
| @Service | 使用在service层类上，用于实例化Bean |
| @Repository | 使用在dao层类上，用于实例化Bean |
| @Autowired | 使用在字段上，用于根据类型依赖注入 |
| @Qualifier | 结合@Autowired一起使用，用于根据名称进行依赖注入 |
| @Resource | 相当于@Autowired+@Qualifier，根据名称进行注入 |
| @Value | 注入普通属性 |
| @Scope | 标注Bean的作用范围 |
| @PostConstruct | 实用在方法上标注，该方法是Bean的初始化方法 |
| @PreDestroy | 使用在方法上标注，该方法是Bean的销毁方法 |
使用@Component或 @Repository标识UserDaoImpl进行实例化
1 //
使用@Component或 @Service标识UserServiceImpl进行实例化
使用@Autowired或@Autowired+@Qualifier或@Resource进行userDao的注入
1 //
2 //@Component("userService")
3 @Service("userService")
4 public class UserServiceImpl implements UserService{
5 //
然后，来到web层进行测试，运行结果如下：
可以发现报错了，说没有UserService这个bean定义的异常，那么为什么没有呢，那么刚刚把xml中的配置转成注解的时候，用的是Component标签，注入用到的是Autowired和Qualifier，但是现在有个问题，我们把这个注解配到这，还得告诉Spring，它要去哪里拿，去找那个注解，然后读取注解再帮忙创建我们需要的对象，所以要怎么告诉，就得配置组件扫描。
注意：
使用注解开发时，需要在applicationContext.xml中配置组件扫描，作用是指定那个包及其包下的Bean需要进行扫描以便于识别使用注解配置的类、字段和方法。
<context:component-scan base-package="com.ntect"/>
base-package：属性就是基本包，你给定一个基本包，Spring就会扫描这个包以及它的子包后边的所有的bean都会被扫描，扫到对应的注解，Spring就会帮你去解析，就能完成bean的创建和注入工作
配置完组件扫描，再去测试，运行结果：
使用@Value进行字符串注入
1 @Repository("userDao")
2 public class UserDaoImpl implements UserDao{
3
4 @Value("aabcccddddd") //普通数据
5 private String str;
6 @Value("${jdbc.driver}") //注入外部数据
7 private String driver;
8
9 public void save() {
10 System.out.println(str);
11 System.out.println(driver);
12 System.out.println("Save Running....");
13 }
14 }
使用@Scope 标注Bean的范围
@Service("userService")
@Scope("prototype")
public class UserServiceImpl implements UserService{
.......
}
使用@PostConstruct 标注初始化方法，使用@PreDestroy 标注销毁方法
1 @PostConstruct
2 public void init() {
3 System.out.println("Service对象的初始化方法");
4 }
5 @PreDestroy
6 public void destory(){
7 System.out.println("Service对象的销毁方法");
8 }
9
10 public class UserController {
11 public static void main(String[] args) {
12 ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
13 UserService userService = app.getBean(UserService.class);
14 userService.save();
15 app.close();
16 }
17 }
2.2 Spring新注解
使用以上注解不能全部替代xml配置文件，还需要使用注解替代的配置如下：
-
非自定义的Bean的配置：
-
加载properties文件的配置：<context:property-placeholder>
-
组件扫描配置：<context:component-scan>
-
引入其他文件：
| 注解 | 说明 |
|---|---|
| @Configuration | 用于指定当前类是一个Spring配置类，当创建容器时会从该类上加载注解 |
| @ComponentScan | 用于指定Spring在初始化容器时要扫描的包 作用和在Spring的xml配置文件中的 |
| @Bean | 使用在方法上，标注将该方法的返回值存储到Spring容器中 |
| @propertySource | 用于加载 .properties 文件中的配置 |
| @import | 用于导入其他配置类 |
1 //context:property-placeholder location="classpath:jdbc.properties"/>
2 @PropertySource("classpath:jdbc.properties")
3 public class DataSourceConfiguration {
4
5 @Value("${jdbc.driver}")
6 private String driver;
7 @Value("${jdbc.url}")
8 private String url;
9 @Value("${jdbc.username}")
10 private String username;
11 @Value("${jdbc.password}")
12 private String password;
13
14 @Bean("dataSource") //Spring会将当前方法的返回值以指定存储到Spring容器中
15 public DataSource getDatasource() throws PropertyVetoException {
16 ComboPooledDataSource dataSource = new ComboPooledDataSource();
17 dataSource.setDriverClass(driver);
18 dataSource.setJdbcUrl(url);
19 dataSource.setUser(username);
20 dataSource.setPassword(password);
21 return dataSource;
22 }
1 //标志该类是Spring的核心配置类
2 @Configuration
3 //
加载核心配置进行测试
1 public class UserController {
2 public static void main(String[] args) {
3 ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfiguration.class);
4 UserService userService = app.getBean(UserService.class);
5 userService.save();
6 }
7 }
3.1 原始junit测试Spring的问题
在测试类中的每个方法都要有如下两行代码，其作用是获取容器。如果没有则会提示空指针异常
ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
DataSource dataSource = app.getBean(DataSource.class);
3.2 解决思路
-
使SpringJunit负责创建Spring容器，需要告诉配置文件的名称
-
将需要进行测试Bean 直接在测试类中进行注入
3.3 Spring集成Junit步骤
-
导入Spring集成Junit的坐标
-
使用@Runwith注解替换原来的运行期
-
使用@ContextConfiguration指定配置文件或配置类
-
使用@Autowired注入需要测试的对象
-
创建测试方法进行测试
3.4 Spring集成Junit代码实现
1、导入Spring集成Junit的坐标
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>5.3.16version>
<scope>testscope>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-testartifactId>
<version>5.3.16version>
dependency>
2、使用@Runwith注解替换原来的运行期
@RunWith(SpringJUnit4ClassRunner.class)
public class SpringJunitTest {
}
3、使用@ContextConfiguration指定配置文件或配置类
1 @RunWith(SpringJUnit4ClassRunner.class)
2 //加载Spring核心配置类
3 //@ContextConfiguration(classes = {SpringConfiguration.class})
4 //加载Spring核心配置文件
5 @ContextConfiguration("classpath:applicationContext.xml")
6 public class SpringJunitTest {
7
8 }
4、使用@Autowired注入需要测试的对象
1 @RunWith(SpringJUnit4ClassRunner.class)
2 //加载Spring核心配置类
3 //@ContextConfiguration(classes = {SpringConfiguration.class})
4 //加载Spring核心配置文件
5 @ContextConfiguration("classpath:applicationContext.xml")
6 public class SpringJunitTest {
7
8 @Autowired
9 private UserService userService;
10
11 }
5、 创建测试方法进行测试
1 @RunWith(SpringJUnit4ClassRunner.class)
2 //加载Spring核心配置类
3 //@ContextConfiguration(classes = {SpringConfiguration.class})
4 //加载Spring核心配置文件
5 @ContextConfiguration("classpath:applicationContext.xml")
6 public class SpringJunitTest {
7
8 @Autowired
9 private UserService userService;
10
11 @Test
12 public void UserServiceTest(){
13 userService.save();
14 }
15 }
运行结果：
