Spring（二）--IoC操作bean管理

1、什么是Bean管理

1、Bean管理指的是两个操作
（1）Spring创建对象
（2）Spring注入属性
2、Bean管理操作有两种方式
（1）基于xml配置文件方式实现
（2）基于注解方式实现

2IoC操作Bean管理（基于xml）

2.1基于xml方式创建对象

<bean id="user" class="com.service.User"></bean>
（1）在spring配置文件中，使用bean标签，标签里面添加对应属性，就可以实现对象创建

（2）在bean标签有很多属性，常用的属性：
（a）id属性：唯一标识
（b）class属性：类全路径
（c）name属性（不常用）：与id相似，但可以加特殊符号

（3）创建对象时候，默认也是执行无参数构造方法

2.2 基于xml方式注入属性

（1）DI：依赖注入，就是注入属性。是IoC中的一个具体实现。

2.2.1第一种注入方式：使用set方法进行注入

（1）创建类。定义属性和对应的set方法

public class Book implements Serializable {
    //创建属性
    private String name;
    private String author;
    //
    public void setName(String name){
        this.name = name;
    }

    public void setAuthor(String author) {
        this.author = author;
    }
}

xml文件：

<bean id="book" class="com.ljc.pojo.Book">
        <!--使用property完成属性注入
            name：类里面属性的名称
            value：向属性注入的值
        -->
        <property name="name" value="老人与海"></property>
        <property name="author" value="海明威"></property>
    </bean>

测试：

 @Test
    public void testBook1(){
        //1 加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        Book book = context.getBean("book", Book.class);
        System.out.println(book);
    }

2.2.2第二种注入方式：使用有参构造进行注入

（1）创建类，定义属性，创建属性对应的有参构造方法

public class Orders {
    private String name;
    private String address;

    //创建有参构造
    public Orders(String name, String address) {
        this.name = name;
        this.address = address;
    }
}

(2)在Spring的配置文件中进行配置

 <!--使用有参构造注入属性-->
    <bean id="Orders" class="com.ljc.pojo.Orders">
        <constructor-arg name="name" value="computer"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
    </bean>

2.2.3p名称空间注入（了解）：

（1）使用p名称空间注入可以简化基于xml配置方式
第一步：在xml的约束中加入p名称空间
xmlns:p="http://www.springframework.org/schema/p"

第二步 进行属性注入，在bean标签里面进行操作

<bean id="book" class="com.ljc.pojo.Book" p:bname="xxx"
p:bauthor="xxx"></bean>

2.3xml注入其他类型属性**

2.3.1字面量（固定值）

（1）null

<bean id="book" class="com.ljc.pojo.Book">
        <!--null值-->
        <property name="address">
            <null/>
        </property>
    </bean>

（2）属性值包含特殊符号

<property name="address">
	<value><![CDATA[<<XXX>>]]></value>
</property>

2.3.2注入属性-外部bean

（1）创建service类和dao类
（2）在service调用dao里面的方法
（3）在Spring配置文件中进行配置

public class UserService {
    //创建UserDao类型属性，生成set方法
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        System.out.println("service add.....");
        userDao.update();
    }
}

<!--1 service和dao对象创建-->
    <bean id="userService" class="com.ljc.service.UserService">
        <!--注入userDao对象
            name属性：类里面属性名称
            ref属性：创建userDao对象bean标签id值
        -->
        <property name="userDao" ref="userDao"></property>
    </bean>
    <bean id="userDao" class="com.ljc.dao.UserDaoImpl"></bean>

2.3.3注入属性-内部bean

(1)一对多关系：部门和员工
一个部门可以有多个学生，一个员工属于一个部门。。部门是一，员工是多
(2)在实体类之间表示一对多关系

/**
 * 部门类
 */
public class Dept {
    private String dname;
	
    public void setDname(String dname) {
        this.dname = dname;
    }
}

/**
 * 员工类
 */
public class Emp {
    private String ename;
    private String gender;
    //使用对象形式表示员工属于一个部门
    private Dept dept;

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}

<!--内部bean-->
	<bean id="emp" class="com.ljc.pojo.Emp">
        <property name="ename" value="Jay"></property>
        <property name="gender" value="man"></property>
        <!--设置对象类型属性（使用外部bean的方法也能实现）-->
        <property name="dept">
            <bean id="dept" class="com.ljc.pojo.Dept">
                <property name="dname" value="销售部"></property>
            </bean>
        </property>
    </bean>

(3)在Spring配置文件中进行配置

2.3.4注入属性-内部bean和级联赋值

(1)第一种写法

<!--级联赋值-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
<!--设置两个普通属性-->
	<property name="ename" value="Joy"></property>
	<property name="gender" value="man"></property>
<!--级联赋值-->
	<property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.atguigu.spring5.bean.Dept">
	<property name="dname" value="销售部"></property>
</bean>

(2)第二种写法
在Emp实体类生成Dept的get方法
public Dept getDept() {
return dept;
}

<!--级联赋值-->
<bean id="emp" class="com.atguigu.spring5.bean.Emp">
<!--设置两个普通属性-->
	<property name="ename" value="lucy"></property>
	<property name="gender" value="女"></property>
<!--级联赋值-->
	<property name="dept" ref="dept"></property>
	<property name="dept.dname" value="技术部"></property>
</bean>
<bean id="dept" class="com.atguigu.spring5.bean.Dept">
	<property name="dname" value="财务部"></property>
</bean>

2.3.5注入集合类型属性

1、注入数组类型属性
2、注入List集合类型属性
3、注入Map集合类型属性
（1）创建类，定义数组、list、map、set 类型属性，生成对应 set 方法

public class Student {
    //1数组类型属性
    private String[] courses;
    //2list集合类型属性
    private List<String> list;
    //3Map类型属性
    private Map<String,Object> maps;
    //4Set集合类型属性
    private Set<String> set;

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMaps(Map<String, Object> maps) {
        this.maps = maps;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }
}

(2)在spring配置文件进行配置

    <bean id="student" class="com.ljc.collectiontype.Student">
        <!--数组类型属性注入-->
        <property name="courses">
            <array>
                <value>111</value>
                <value>222</value>
                <value>333</value>
            </array>
        </property>
        <!--list类型属性注入-->
        <property name="list">
            <list>
                <value>aaa</value>
                <value>bbb</value>
            </list>
        </property>
        <!--map类型注入-->
        <property name="maps">
            <map>
                <entry key="Java" value="java"></entry>
                <entry key="Mybatis" value="mybatis"></entry>
            </map>
        </property>
        <!--set类型注入-->
        <property name="set">
            <set>
                <value>111</value>
                <value>222</value>
            </set>
        </property>
    </bean>

2.3.6在集合里面设置对象类型值

创建Course类，在Student类中创建listCourse属性

<!--创建多个course对象-->
    <bean id="course1" class="com.ljc.collectiontype.Course">
        <property name="cname" value="Java"></property>
    </bean>
    <bean id="course2" class="com.ljc.collectiontype.Course">
        <property name="cname" value="C"></property>
    </bean>
    <bean id="course3" class="com.ljc.collectiontype.Course">
        <property name="cname" value="Python"></property>
    </bean>
	
	 <!--注入list集合类型，值是对象-->
    <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
                <ref bean="course3"></ref>
            </list>
    </property>

2.3.7把集合注入部分提取出来

（1）在spring配置文件中引入名称空间util
xmlns:util="http://www.springframework.org/schema/util”
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
（2）使用util标签完成list集合注入提取

<!--1 提取list集合类型属性注入-->
    <util:list id="bookList">
        <value>11</value>
        <value>22</value>
        <value>33</value>
    </util:list>

    <!--2 提取list集合类型属性注入使用-->
    <bean id="book" class="com.ljc.collectiontype.Book">
        <property name="list" ref="bookList"></property>
    </bean>

2.4IoC操作Bean管理（FactoryBean）

1、Spring有两种bean，一种普通bean，另外一种工厂bean（FactoryBean）

2、普通bean：在配置文件中定义bean类型就行返回类型

3、工厂bean：在配置文件定义bean类型可以和返回类型不一样
第一步 创建类，让这个类作为工厂bean，实现FactoryBean接口

第二部 实现接口里面的方法，在实现的方法中定义返回的bean类型

public class MyBean implements FactoryBean<Course> {

    @Override
	//设置返回的类型
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("xxx");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return FactoryBean.super.isSingleton();
    }
}

<bean id="myBean" class="com.ljc.factorybean.MyBean"></bean>

测试代码

public void test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring3.xml");
        Course course = context.getBean("myBean", Course.class);
        System.out.println(course);
    }

3、xml自动装配

3.1什么是自动装配

（1）根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入
（2）bean标签属性autowire，配置自动装配
autowire属性常用两个值：
（a）byName根据属性名称注入，注入值bean的id值和类属性名称一样

（b）byType根据属性类型进行注入

3.2演示自动装配过程

前提：Emp类中有Dept类型的属性
byName:

<bean id="emp" class="com.ljc.autowire.Emp" autowire="byName">
<!--        <property name="dept" ref="dept"></property>-->
    </bean>

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

byType:

<bean id="emp" class="com.ljc.autowire.Emp" autowire="byType">
<!--        <property name="dept" ref="dept"></property>-->
    </bean>

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

4、引入外部属性文件

4.1直接配置数据库信息

（1）引入druid pom依赖
（2）配置druid连接池

<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/userDB"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

4.2引入外部属性文件配置数据库连接池

(1)创建外部属性文件，properties格式文件

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDB
prop.userName=root
prop.password=root

(2)把外部properties属性文件引入到spring配置文件中
1、引入context名称空间
xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-context.xsd
2、在 spring配置文件使用标签引入外部属性文件

    <context:property-placeholder location="jdbc.properties"/>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${prop.driverClass}"></property>
        <property name="url" value="${prop.url}"></property>
        <property name="username" value="${prop.userName}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean>

5、IoC管理Bean操作（基于注解方式）

5.1什么是注解

（1）注解是代码特殊标记，格式：@注解名称(属性名称=属性值,属性名称=属性值)
（2）使用注解，注解可以作用在类、方法、属性上面
（3）使用注解目的：简化xml配置

5.2Spring针对Bean管理中创建对象提供注解

(1)@Component:Spring容器中提供一种普通组件，可以创建对象
(2)@Service：用在业务逻辑层或者Service层上
(3)@Controller：用在外部层
(4)@Repository：用在持久层
以上四个注解功能是一样的，都可以用来创建bean实例

5.3基于注解实现对象创建

第一步：引入aop依赖

<dependency> 
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>

第二步：开启组件扫描
(1)加入Context名称空间
(2) 如果扫描多个包，多个包使用逗号隔开
(3) 扫描包上层目录
<context:component-scan base-package="com.ljc"></context:component-scan>
第三步：创建类，在类上面添加创建对象注解

@Service(value = "userService")//value与xml配置bean的id等价，不写默认为类名称首字母小写
public class UserService {
    public void say(){
        System.out.println("xxx");
    }
}

5.4开启组件扫描细节配置

 <!--示例1
        use-default-filters="false":表示不适用默认filter，使用自己配置的filter
        context:include-filter：设置扫描哪些内容，如expression="org.springframework.stereotype.Controller"扫描带@Controller注解
    -->
    <context:component-scan base-package="com.ljc" 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.ljc">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

5.5基于注解方式实现属性注入

(1)@Autowired:根据属性类型进行自动装配
第一步：把service和dao对象创建，在service和dao类添加创建对象注解
第二步：在service注入dao对象，在service类添加dao类型属性，在属性上面使用注解（不需要添加set方法）
创建UserDao接口和UserDaoImpl，使用注解会把实现类注入

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

(2)@Qualifier:根据属性名称进行注入
@Qualifier注解的使用要与@Autowired一起使用，当一个接口有多个实现类时，@Autowired不知道注入哪个实现类，需要@Qualifier(value="xxx")指定名称注入

//添加注入属性注解
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

(3)@Resource:可以根据类型注入，可以根据名称注入(是javax包中的注解)

//  @Resource//根据类型进行注入
    @Resource(name = "userDaoImpl1")//根据名称注入 
    private UserDao userDao;

(4)@Value:注入普通类型属性

    @Value(value="aaa111")
    private String name;

6、完全注解开发

(1)创建配置类，替代xml配置文件

@Configuration //作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.ljc"})
public class SpringConfig {
}

(2)编写测试类

public void test2(){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("SpringConfig.class");
        UserService userService = context.getBean("userService", UserService.class);
        userService.say();
    }