Spring（二）--FactoryBean、bean的后置处理器、数据库连接池、引用外部文件、使用注解配置bean等

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

实验1：配置通过静态工厂方法创建的bean [通过静态方法提供实例对象，工厂类本身不需要实例化！]

1.创建静态工厂类

public class StaticFactory { private static HashMap<String, Book> map = null; static{
map = new HashMap<>();
map.put("book01", new Book("java", "you", 33.33));
map.put("book02", new Book("c++", "you", 66.66));
map.put("book03", new Book("c#", "you", 99.99));
} public static Book getBookById(String id){
return map.get(id);
}
}

工厂本身不创建对象，而是通过其提供的静态方法获取对象

如果不写 <constructor-arg> 会报 method="getBookById" 构造器需要参数的错误

所以通过<constructor-arg> 传一个参数

在 junitTest 中会获取到 book02 中的内容

实验2：配置通过实例工厂方法创建的bean [通过实例方法提供实例对象，工厂类本身需要先创建对象！]

实例工厂先创建一个工厂对象，然后通过工厂对象的方法获取一个实例

将静态工厂类中的方法复制，并修改为非静态方法【去除static】

public class InstanceFactory { private HashMap<String, Book> map = null; {
map = new HashMap<>();
map.put("book01", new Book("java", "you", 33.33));
map.put("book02", new Book("c++", "you", 66.66));
map.put("book03", new Book("c#", "you", 99.99));
} public Book getBookById(String id){ return map.get(id);
}
}

先给工厂类本身创建一个对象<bean id="instanceFactory" class="com.neuedu.spring.entity.InstanceFactory"></bean>

再给方法创建一个对象，bean中不用写 class ，写 factory-bean，依赖于 instanceFactory

此时需要一个工厂方法factory-method

还需要给工厂方法提供一个参数<constructor-arg value="book03">

从实例中获取book03

public void test() {
Object bean = ioc.getBean("bookFromInstanceFactory");
System.out.println(bean);
}

实验3：配置FactoryBean

创建 MyFactoryBean 实现 FactoryBean<>接口

返回对象就是调用 getObject() 方法

public class MyFactoryBean implements FactoryBean<Book>{ @Override
public Book getObject() throws Exception {
//Spring的IOC容器就是调用该方法返回的对象
return new Book("java", "you", 33.33);
} @Override
public Class<?> getObjectType() {
//返回对象的类型
return Book.class;
} @Override
public boolean isSingleton() {
return true;
}
}

<bean id="myFactoryBean" class="com.neuedu.spring.entity.MyFactoryBean"></bean>

实验4：测试bean的后置处理器

在bean的初始化方法【init】调用前后执行操作的专门的对象

Object 代表 bean 对象，String 代表 bean 对象的 id

自定义后置处理器实现该接口：BeanPostProcessor

public class MyBeanPostProcessor implements BeanPostProcessor{ @Override
public Object postProcessAfterInitialization(Object object, String beanId) throws BeansException {
System.out.println("After---"+object+"---"+beanId);
return object;
} @Override
public Object postProcessBeforeInitialization(Object object, String beanId) throws BeansException {
System.out.println("Before---"+object+"---"+beanId);
return object;
}
}

没有 bean 对象，后置处理器不会执行

如果只这么写的话，是不会输出什么的

所以在这之前需要创建一个 bean 对象

在 Book 类中创建 init( ) 方法，输出“Book对象的初始化方法”

以观察是否在对象的初始化方法之前和之后处理

bean对象属性的检查，属性名、属性类型是否规范

数据库连接池：

> 数据库连接池就是存放数据库连接（Connection）的集合

> 我们获取一个数据库连接是一个相对很麻烦的过程，

如果我们获取一个数据库连接，使用一次以后就给它关闭了

下一次再去使用的时候就要重新创建一个新的数据库连接

> 所以我们提出了一个数据库连接池的概念，数据库连接池放的都是数据库连接（Connection）

我们在去使用数据库连接时候，不用再去重新创建数据库连接，而是直接从池中获取，

使用完的数据库连接，也不是直接销毁，而是要放回到连接池。

> 数据库连接池的常见的属性：

初始连接数量：数据连接池创建以后，保存数据库连接的数量

最小空闲连接数：数据库连接池最少得未使用的数据库连接的数量

最大空闲连接数：数据库连接池最大闲置连接数，当闲置连接数满了以后，将不会有其他连接进入池

每次增加连接数：当数据库连接都被占用以后，一次性增加的数据库连接的个数

最大连接数：数据库连接池的最大容量，当最大连接数饱和了，则不再创建新的数据库连接

最大等待时间：当数据库连接池饱和以后，等待获取数据库连接的时间

> 常见的数据库连接池

- 所有的数据库连接池都需要实现DataSource，当使用数据库连接池是，我们便不再需要使用DriverManger获取数据库连接而是使用DataSource。

- Connection getConnection()

- 从数据库连接池中获取数据库连接对象

1.DBCP

- DBCP是Apache出品的一款数据库连接

- DBCP依赖于commons-pool

- 使用DBCP需要导入两个jar包：

commons-dbcp-1.4.jar

commons-pool-1.5.5.jar

- 当我们通过数据库连接池获取数据库连接以后，我们所获取到数据库连接已经不是我们熟悉的那个Connection

数据库连接池对Connection对象进行了包装，它修改Connection的close()方法

再去调用close()数据库连接将不会真的关闭，而是要放回到数据库连接池中，供其他线程使用。

- 核心类：

BasicDataSourceFactory

2.C3P0（重点）

- C3P0使用的是XML作为配置文件

- 使用c3p0需要导入一个jar包：c3p0-0.9.1.2.jar

- 导入c3p0的配置文件：

1.配置文件的名字：c3p0-cofig.xml

2.配置文件要求放到类路径下（src）

- 核心类： ComboPooledDataSource

- 注意：

DataSource就相当于池子，我们的数据库连接都是从DataSource中获取的，

如果程序中有多个DataSource的实例，那么我们说你还不如不用数据库连接池。

实验5：引用外部属性文件

新建文件 jdbc.properties

properties 中都是键值对格式

<context:property-placeholder location="classpath:jdbc.properties"/><bean id="comboPooledDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="driverClass" value="${jdbc.driver}"></property>
<property name="jdbcUrl" value="${jdbc.url}"></property>
</bean>

加载了配置文件的地址location="classpath:jdbc.properties" ，所以${ }能直接使用

通过 bean 中的连接信息

可以直接从连接池获取连接 bean. getConnection()

@Test
public void test() throws SQLException {
DataSource bean = ioc.getBean(DataSource.class);
System.out.println(bean.getConnection());
}

执行查询操作

@Test
public void test() throws SQLException {
DataSource bean = ioc.getBean(DataSource.class);
Connection conn = bean.getConnection();
String sql = "select * from student";
PreparedStatement ps = conn.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while(rs.next()){
String name = rs.getString("name");
String email = rs.getString("email");
String school = rs.getString("school");
String score = rs.getString("score");
System.out.println(name+"--"+email+"--"+school+"--"+score);
}
}

补充：

用注解就不用get/set方法

新建一个 AController 类，属性是外部文件中的值，在类上加 Controller注解并导包【aop】

加个注解 Value，注解里用EL表达式获取外部文件每个值

@Controller
public class AController { @Value("${jdbc.username}")
private String username;
//${jdbc.username}将值赋给username
@Value("${jdbc.password}")
private String password; @Value("${jdbc.driver}")
private String driver; @Value("${jdbc.url}")
private String url; @Override
public String toString() {
return "AController [username=" + username + ", password=" + password + ", driver=" + driver + ", url=" + url
+ "]";
}
}

<context:component-scan base-package="com.neuedu"></context:component-scan>
<context:property-placeholder location="classpath:jdbc.properties"/>

@Test
public void test01(){
AController bean = ioc.getBean(AController.class);
System.out.println(bean);
}

实验6：基于XML的属性装配

（1）手动配置

新建两个类，一个类中包含另一个类为属性，

<bean id="userService" class="com.neuedu.spring.entity.UserService"></bean>
<bean id="userAction" class="com.neuedu.spring.entity.UserAction">
<property name="userService" ref="userService"></property>
</bean>

（2）自动装配

① byType ：如果UserAction 类中的userService的属性类型 UserService可以在IOC容器中找到，成功

与userService名字无关，只与属性类型相关

② byName：如果 UserAction 中有属性名为userService 就可以在IOC容器中找到

只看名字

实验7：使用注解配置bean

（1）声明bean的注解

@Component 将当前类声明为IOC容器中的一个普通的组件，

@Controller 将当前类声明为IOC容器中的一个控制器组件，接受web前端请求

@Service 将当前类声明为IOC容器中的业务逻辑层组件，

@Repository 将当前类声明为IOC容器中的一个持久化层组件，

（2）使用基于注解的bean的配置，需要额外导入一个jar包：spring-aop-4.0.0.RELEASE.jar

（3）需要设置自动扫描的包

<context:component-scan base-package="com.neuedu"></context:component-scan>

三种写法：

（1）直接写类名

（2）类名首字母小写

（3）在@Controller 后加上重定义的名字，如@Controller(value="asd")

value 可省

@Test
public void test(){
// UserController bean = ioc.getBean(UserController.class);
// Object bean = ioc.getBean("userController");
Object bean = ioc.getBean("asd");
System.out.println(bean);
}

Spring根据上述注解其实并不能分辨当前类是否真的是一个Controller或Dao，因为标记的类和注解不对应也没有语法错误。也就是将 controller层的注解写成@Service 也没错，但在实际工作中，肯定要将专门的注解标记在对应的类上面。

实验8：通过注解分别创建Dao、Service、Controller

分别在以下三层，依次调用下一层的方法，最后在dao层输出一句话

在Test 中观察是否能输出那句话

@Controller
public class UserController {
@Autowired
private UserService userService; public void getStudentInfo(){
userService.getStudentInfo();
}
}

@Service
public class UserService {
@Autowired
private UserDao userDao; public void getStudentInfo() {
userDao.getStudentInfo();
}
}

@Repository
public class UserDao {
public void getStudentInfo() {
System.out.println("enenenenen"); }
}

@Test
public void test(){
UserController bean = ioc.getBean(UserController.class);
bean.getStudentInfo();
}

实验9：使用context:exclude-filter指定扫描包时不包含的类

使用context:include-filter指定扫描包时要包含的类

expression 中写的是扫描包时不包含的类的全类名【注解的全类名】

<context:component-scan base-package="com.neuedu">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

base-package属性指定一个需要扫描的基类包，Spring容器将会扫描这个基类包及其子包中的所有类

use-default-filters 默认为true ，当为false 时，代表不再使用默认的过滤器，在IOC容器中都找不到了

但是include-filter 代表要扫描的包，所以在Test中可以在 IOC中找到controller

<context:component-scan base-package="com.neuedu" use-default-filters="false">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

使用的是所建类的全类名，而不是 @Controller 的全类名

这样在 IOC容器中也找不到

<context:component-scan base-package="com.neuedu">
<context:exclude-filter type="aspectj" expression="com.neuedu.spring.entity.UserController"/>
</context:component-scan>

实验10：使用@Autowired注解实现根据类型实现自动装配

[1]首先检测标记了@Autowired注解的属性的类型

[2]根据类型进行装配

[3]如果指定类型的bean不止一个，那么根据需要被装配的属性的属性名做id的值，查找bean

[4]如果根据id值还是没有找到bean，可以使用 @Qualifier 注解手动指定要装配的bean的id

@Autowired 首先是根据类型来注入

根据 service 的类型到 IOC中找

@Controller
public class UserController {
@Autowired
private UserService service; public void say(){
service.getStudentInfo();
}
}

因为 service 的类型是 UserService ，所以当 UserService有一个子类的时候

根据类型就会找不到

所以就会通过姓名查找

通过更改 service层的value值

@Service(value="service")
public class UserService {
@Autowired
private UserDao userDao; public void getStudentInfo() {
userDao.getStudentInfo();
}
}

@Qualifier 指定一个value 值，去 IOC容器中找它

@Autowired(required=false) 指：就算找不到也不会报错

@Controller
public class UserController {
@Autowired(required=false)
@Qualifier(value="BService")
private UserService ser; public void say(){
ser.getStudentInfo();
}
}