spring学习记录-IOC后部分

5.FactoryBean
1、Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）
2、普通 bean：在配置文件中定义 bean 类型就是返回类型
3、工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样
第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean
第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型（通过重写getObject()方法）

public class MyBean implements FactoryBean<Course> {
 //定义返回 bean
 @Override
 public Course getObject() throws Exception {
 Course course = new Course();
 course.setCname("abc");
 return course;
 }
 @Override
 public Class<?> getObjectType() {
 return null;
 }
 @Override
 public boolean isSingleton() {
 return false;
 } }<bean id="myBean" class="com.lbl.spring5.factorybean.MyBean">
</bean>
@Test
public void test3() {
 ApplicationContext context =
 new ClassPathXmlApplicationContext("bean3.xml");
 Course course = context.getBean("myBean", Course.class);
 System.out.println(course);
}

6.bean 的作用域
spring默认创建的是单实例
即：

设置单实例还是多实例：

       <bean id="book" class="com.lbl.collection.Book"  scope="prototype"><!--默认scope="singleton"单实例且在加载配置文件时就已经创建好了-->
                                                                        <!--多实例是在context.getBean方法时才创建对象-->
            <property name="list" ref="bookList"></property>
            </bean>

7.bean的生命周期：

public class Orders {

    public Orders() {
        System.out.println("第一步，执行无参构造创建bean实例");
    }
    private String oname;

    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步，调用set方法设置值");
    }

    //创建执行的初始化方法
    public void initMethod(){
        System.out.println("第三步，执行初始化方法");
    }

    //执行销毁的方法
    public  void destoryMethod(){
        System.out.println("第五步，执行销毁方法");
    }
}

前后置处理器：

public class MybeanPost implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在第三步初始化之前执行的方法");
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在第三步初始化之后执行的方法");
        return null;
    }
}

bean.xml:

    <bean id="orders" class="com.lbl.collection.bean.Orders" init-method="initMethod" destroy-method="destoryMethod">
        <property name="oname" value="手机"></property>
    </bean>

<!--配置后置处理器，实现接口后每个类都会加载-->
        <bean id="mybeanPost" class="com.lbl.collection.bean.MybeanPost"></bean>

测试：

   @Test
    public void testCollection2(){
//        ApplicationContext context=new ClassPathXmlApplicationContext("bean4.xml");
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("bean.xml");
        Orders orders = context.getBean("orders", Orders.class);
        System.out.println("第四步，获取对象");
        //手动调用销毁方法
        context.close();
    }

结果：

8.自动装配：根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入

2、演示自动装配过程
（1）根据属性名称自动注入
<!--实现自动装配
 bean 标签属性 autowire，配置自动装配
 autowire 属性常用两个值：
 byName 根据属性名称注入 ，注入值 bean 的 id 值和类属性名称一样
 byType 根据属性类型注入
--><bean id="emp" class="com.lbl.spring5.autowire.Emp" autowire="byName">
</bean> 

省略掉了这一行： <!--<property name="dept" ref="dept"></property>-->

<bean id="dept" class="com.lbl.spring5.autowire.Dept"></bean>

9.外部属性文件
以druid为例：
（一）直接配置数据库信息，导入依赖后：
bean.xml：

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
 <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
 <property name="url" 
value="jdbc:mysql://localhost:3306/数据库名称"></property>
 <property name="username" value="root"></property>
 <property name="password" value="root"></property>
</bean>

引入外部属性文件配置数据库连接池：
（二）jdbc.properties：

lbl.driverClass=driverClassName" value="com.mysql.cj.jdbc.Driver
lbl.url=jdbc:mysql://localhost:3306/userDb
lbl.username=root
lbl.password=root

 <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${lbl.driverClass}"></property>
        <property name="url" value="${lbl.url}"></property>
        <property name="username" value="${lbl.username}"></property>
        <property name="password" value="${lbl.password}"></property>
    </bean>
    <!--引入外部属性文件-->

10.基于注解的方式创建对象
1、什么是注解
（1）注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值…)
（2）使用注解目的：简化 xml 配置
2、Spring 针对 Bean 管理中创建对象提供注解
（1）@Component
（2）@Service
（3）@Controller
（4）@Repository
上面四个注解功能是一样的，都可以用来创建 bean 实例

3.基于注解方式来实现创建对象

首先导入spring-aop依赖，
第二步开启注解扫描：

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

第三步 创建类，在类上面添加创建对象注解：（//默认值是类名称，首字母小写比如：UserService – userService）

@Component(value = "userService") //<bean id="userService" class=".."/>
public class UserService {
 public void add() {
 System.out.println("service add.......");
 } }

第四步：开启组件扫描细节配置(不使用默认的filter，使用自己配置的filter)

 use-default-filters="false" 表示现在不使用默认 filter，自己配置 filter
 context:include-filter ，设置扫描哪些内容
--><context:component-scan base-package="com.lbl" use-default-filters="false">
 <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!--示例 2
 下面配置扫描包所有内容
 context:exclude-filter： 设置哪些内容不进行扫描
--><context:component-scan base-package="com.atguigu">
 <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

4.基于注解来实现属性注入：
（1）@Autowired：根据属性类型进行自动装配
第一步 把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解
第二步 在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

@Service
public class UserService {
 //定义 dao 类型属性
 //不需要添加 set 方法
 //添加注入属性注解
 @Autowired 
 private UserDao userDao;
 public void add() {
 System.out.println("service add.......");
 userDao.add();
 } }

（2）@Qualifier：根据名称进行注入
这个@Qualifier 注解的使用，和上面@Autowired 一起使用
//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao; 

（3）@Resource：可以根据类型注入，可以根据名称注入
//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao; 

（4）@Value：注入普通类型属性
@Value(value = "abc")
private String name;

5.完全注解开发

（1）创建配置类，替代 xml 配置文件
@Configuration //作为配置类，替代 xml 配置文件
@ComponentScan(basePackages = {"com.lbl"})
public class SpringConfig {
}

（2）编写测试类
@Test
public void testService2() {
 //加载配置类
 ApplicationContext context
 = new AnnotationConfigApplicationContext(SpringConfig.class);
 UserService userService = context.getBean("userService", 
UserService.class);
 System.out.println(userService);
 userService.add();
}