Spring+SpringMVC+MyBatis从零开始学——第二章 Spring中的配置

第二章 Spring中的Bean

2.1 Bean的配置

属性
id
name
class
scope
constructor-arg
property
ref
value
list
set
map
entry

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"  
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"      
	   xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
     <!—使用id属性定义bean1，其对应的实现类为com.ssm.Bean1  -->
	<bean id=" bean1" class=" com.ssm.Bean1" />
     <!--使用id属性定义bean2，其对应的实现类为com.ssm.Bean2  -->
     <bean id=" bean2" class=" com.ssm.Bean2" />
</beans>

2.2 bean的作用域

2.2.1 作用域的种类

Bean的作用于有七种，学习两种：

Singleton（单例）：使用singleton定义的Bean在Spring容器中将只有一个实例，
Prototype（原型）：每次通过Spring容器获取的prototype定义的Bean时，容器都将创建一个新的Bean实例。

2.2.2 singleton作用域和prototype作用域

创建一个maven项目，目录结构如下（Maven-springweb项目）：

1. 导入依赖
   Spring的核心依赖Spring-context

 <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.2.RELEASE</version>
 </dependency>

2. 编写Spring的配置文件applicationContext.xml

  <!--scope属性值默认是singleton-->
    <bean id="scope01" class="cn.itcast.Scope" scope="singleton"/>
    <bean id="scope02" class="cn.itcast.Scope" scope="prototype"/>

3. 编写类和测试类
   Scope类：

public class Scope {

}

Test01类：

public class Test01 {
    public static void main(String[] args) {
        //1.初始化spring容器，加载配置文件
        
        System.out.println("singleton:");
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        Scope scope01 = (Scope) ac.getBean("scope01");
        Scope scope02 = (Scope) ac.getBean("scope01");
        System.out.println(scope01);
        System.out.println(scope02);
        
        System.out.println("prototype:");
        Scope scope03 = (Scope) ac.getBean("scope02");
        Scope scope04 = (Scope) ac.getBean("scope02");
        System.out.println(scope03);
        System.out.println(scope04);
    }
}

4. 输出的结果
   

2.3 Bean的装配方式

2.3.1 基于XML的装配

spring提供两种基于XML装配方式：

1. Setter方法注入

要求：
		1. Bean类必须提供一个默认的无参构造方法
		2. Bean类为需要注入的属性提供对应的setter()方法

2. 构造方法注入

要求：
		1. 提供一个带参的构造函数

案例如下（Maven-web项目）：

1. 配置pom.xml,导入依赖

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.2.RELEASE</version>
    </dependency>

2. User.java

public class User {
    private String userName;
    private String password;
    private List<String> list;
    
    //1.基于XML装配方式——setter()方法注入
    public User() {
    }
    public String getUserName() {return userName;}
    public void setUserName(String userName) {this.userName = userName;}
    public String getPassword() {return password;}
    public void setPassword(String password) {this.password = password;}
    public List<String> getList() {return list;}
    public void setList(List<String> list) {this.list = list;}

    //2.基于XML装配方式——构造方法方法注入
    public User(String userName, String password, List<String> list) {
        this.userName = userName;
        this.password = password;
        this.list = list;
    }
    
    @Override
    public String toString() {
        return "Scope{" +
                "userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                ", list=" + list +
                '}';
    }
}

3. 编写Spring的配置文件

//1.setter()方法依赖注入
<bean id="user01" class="cn.itcast.User">
        <!--1. setter方法依赖注入-->
        <property name="userName" value="zhangsan"></property>
        <property name="password" value="111111"></property>
        <property name="list">
            <list>
                <value>"listValuel"</value>
                <value>"listValue2"</value>
            </list>
        </property>
    </bean>
    //1.构造方法方法依赖注入
    <bean id="user02" class="cn.itcast.User">
        <constructor-arg name="userName" value="zhangsan"></constructor-arg>
        <constructor-arg name="password" value="111111"></constructor-arg>
        <constructor-arg name="list">
            <list>
                <value>"listValuel"</value>
                <value>"listValue2"</value>
            </list>
        </constructor-arg>
    </bean>

4. 编写测试类Test02

public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user01 = (User) ac.getBean("user01");
        User user02 = (User) ac.getBean("user02");
        //1.基于XML的装配——setter()方法注入
        System.out.println(user01);
        //2.基于XML的装配——setter()方法注入
        System.out.println(user02);

    }

5. 输出结果

Scope{userName='zhangsan', password='111111', list=["listValuel", "listValue2"]}
Scope{userName='zhangsan', password='111111', list=["listValuel", "listValue2"]}

2.3.2 基于Annotation的装配

1. Spring中定义了一系列的注解

注解名称	说明
@Component	注解描述Spring中的Bean，使用时只需将该注解标注在相应类上即可。
@Repository	用于将数据访问层（DAO层）的类标识为Spring中的Bean，其功能与@Component相同。
@Service	通常作用在业务层（Service层）的类标识为Spring中的Bean，其功能与@Component相同。
@Controller	通常作用在控制层（如Spring MVC的Controller）的类标识为Spring中的Bean，其功能与@Component相同。
@Autowired	用于对Bean的属性变量、属性的setter方法及构造方法进行标注，配合对应的注解处理器完成Bean的自动配置工作。默认按照Bean的类型进行装配。
@Resource	其作用与@Autowired一样。其区别在于@Autowired默认按Bean类型装配，而@Resource默认按照Bean实例名称进行装配。@Resource中有两个重要属性：name和type。Spring将name属性解析为Bean实例名称，type属性解析为Bean实例类型。如果指定name属性，则按实例名称进行装配；如果指定type属性，则按Bean类型进行装配；如果都不指定，则先按Bean实例名称装配，如果不能匹配，再按照Bean类型进行装配；如果都无法匹配，则抛出NoSuchBeanDefinitionException异常。
@Qualifier	与@Autowired注解配合使用，会将默认的按Bean类型装配修改为按Bean的实例名称装配，Bean的实例名称由@Qualifier注解的参数指定。

注意：在上表几个注解中，虽然与@Repository、@Service和@Controller功能与@Component注解的功能相同，但为了使标注类本身用途更加
清晰，建议在实际开发中使用@Repository、@Service和@Controller分别对实现类进行标注。

2. 示例：
   1. 项目结构(Maven-web)
      
   2. 配置依赖

<!--spring的核心依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.2.RELEASE</version>
    </dependency>
    <!--用于对制定包中的注解进行扫描-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.2.2.RELEASE</version>
    </dependency>

3. 类的创建
   UserDao接口

public interface UserDao {
    public void save();
}

UserService接口

public interface UserService {
    public void save();
}

UserController.java

@Controller("userController")
public class UserController {
    @Resource(name="userService")
    private UserService userService;
    public void save(){
        userService.save();
        System.out.println("执行userController.save()");
    }
}

AnnotationTest.java

public class AnnotationTest {
    private static ApplicationContext ac ;
    public static void main(String[] args) {
        ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserController userController = (UserController) ac.getBean("userController");
        userController.save();

    }
}

UserDaoImpl.java

@Repository("userDao")
public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System. out. println("执行userDao.save()");
    }
}

UserServiceImpl.java

@Service("userService")
public class UserServiceImpl implements UserService {
    @Resource(name="userDao")
    private UserDao userDao;
    @Override
    public void save() {
        userDao.save();
        System.out.println("执行userService.save()");

    }
}

3. Spring的配置文件

	<!--通知Spring对指定包的扫描，进行注解的解析-->
    <context:component-scan base-package="cn.itcast"/>

4. 输出结果

执行userDao.save()
执行userService.save()
执行userController.save()