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);
      }
}

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

<bean id="staticFactory" class="com.neuedu.spring.entity.StaticFactory" factory-method="getBookById">
      <constructor-arg value="book02"></constructor-arg>
</bean>

如果不写 <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">

<bean id="instanceFactory" class="com.neuedu.spring.entity.InstanceFactory"></bean>
<bean id="bookFromInstanceFactory" factory-bean="instanceFactory" factory-method="getBookById">
      <constructor-arg value="book03"></constructor-arg>
</bean>

从实例中获取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 -->
<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 id="myBeanPostProcessor" class="com.neuedu.spring.entity.MyBeanPostProcessor"></bean>

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

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

<bean id="book" class="com.neuedu.spring.entity.Book" init-method="init">
     <property name="bookName" value="java"></property>
     <property name="author" value="you"></property>
     <property name="price" value="32.32"></property>
</bean>
<bean id="myBeanPostProcessor" class="com.neuedu.spring.entity.MyBeanPostProcessor"></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名字无关，只与属性类型相关

<bean id="userService" class="com.neuedu.spring.entity.UserService"></bean>
<bean id="userAction" autowire="byType" class="com.neuedu.spring.entity.UserAction"></bean>

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

                    只看名字

<bean id="userService" class="com.neuedu.spring.entity.UserService"></bean>
<bean id="userAction" autowire="byName" class="com.neuedu.spring.entity.UserAction"></bean>

---

实验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();
      }
}