Spring02---IOC 控制反转

一、 Spring Bean Scopes - Bean 的作用域 在 Spring 中，Bean 的作用域决定了从 Spring 容器中返回的 Bean 实例的类型。在 Spring 中，支持以下 5 种类型的作用域：

- singleton — 单例模式，由 IOC 容器返回一个唯一的 bean 实例。 - prototype — 原型模式，被请求时，每次返回一个新的 bean 实例。 - request — 每个 HTTP Request 请求返回一个唯一的 Bean 实例。 - session — 每个 HTTP Session 返回一个唯一的 Bean 实例。 - globalSession — Http Session 全局 Bean 实例。

  注：大多数情况下，你可能只需要处理 Spring 的核心作用域 — 单例模式（ singleton ）和原型模式（ prototype ），默认情况下，作用域是单例模式

1.1 默认情况， 作用于为singleton 1.1.1 创建实体类

package com.chb.test03.zyy;
public class CustomerService
{
    String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

1.1.2、修改SpringBean.xml

1.1.3 测试singleton, 两次获取为同一个对象

1.2 scope为Protptype情况 1.2.1, 修改SpringBean.xml，设置scope="protptype"

1.2.2, 测试scope为Protptype 两次获取的不是同一个对象， 每次获取一个新的对象。

二、什么时候使用singleton, 什么时候使用proptype 接下来我们创建一个用户管理的案例， 来分析什么时候使用singleton, 什么时候使用proptype。 2.1 、创建用户

    package com.chb.Spring.model;

public class User {
    private int id;
    private String username;

    public User() {}

    public User(int id, String username) {
        super();
        this.id = id;
        this.username = username;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + "]";
    }

}

我们一般按照三层架构

• Action
• Service
• Dao

接下来我们从底层开始建设 2.2、Dao层 2.2.1 IUserDao, 提供方法，管理User

package com.chb.Spring.dao;

import com.chb.Spring.model.User;

public interface IUserDao {
    public void add(User user);
    public void delete(int id);
    public void load(int id);
}

2.2.2、实现类UserDao

package com.chb.Spring.dao;

import com.chb.Spring.model.User;

public class UserDao implements IUserDao{

    public void add(User user) {
        System.out.println("UserDao add a " + user);
    }

    public void delete(int id) {
        System.out.println("UserDao delete user " + id);
    }

    public void load(int id) {
        System.out.println("UserDao load User " + id);
    }

}

2.3、service层 2.3.1、IUserService层， 同样有三个方法

package com.chb.Spring.service;

import com.chb.Spring.model.User;

public interface IUserService {
    public void add(User user);
    public void delete(int id);
    public void load(int id);
}

2.3.2、业务的具体实现类： UserService, 最关键地方引入IUserDao

package com.chb.Spring.service;

import com.chb.Spring.dao.IUserDao;
import com.chb.Spring.model.User;

public class UserService implements IUserService {
    //在此处引入IUserDao, 通过IUserDao的实现类， 进行底层数据操作
    private IUserDao iUserDao;


    public void add(User user) {
        iUserDao.add(user);
    }

    public void delete(int id) {
        iUserDao.delete(id);
    }

    public void load(int id) {
        iUserDao.load(id);
    }

}

高层向底层请求， 底层向高层服务 2.4、 Action层 ， 就是我们的控制层， Action 需要控制的对象 User, IUserService, id, 同样有三个方法。

package com.chb.Spring.action;

import com.chb.Spring.model.User;
import com.chb.Spring.service.IUserService;

public class UserAction {
    //操作的对象为User
    private User user;
    //存储是由service层执行， service层调用Dao层
    private IUserService iUserService;
    //删除， load User需要id
    private int id;

    public void add() {
        iUserService.add(user);
    }

    public void delete() {
        iUserService.delete(id);
    }

    public void load() {
        iUserService.load(id);
    }

}

至此，我们已经建好了类， 需要配置文件SpringBean.xml 三、设置配置文件SpringBean.xml 3.1、 首先将三个类添加进去

3.2、为每个依赖类创建getter, setter()，

3.3、设置property name中的值会在userService对象中调用setXX方法来注入,诸如:name="userDao"在具体注入时会调用setUserDao(IUserDao userDao)来完成注入 ref="userDao"表示是配置文件中的bean中所创建的DAO的id

UserAction 依赖于IUserService， 同样设置setter, getter(), 设置property

package com.chb.Spring.action;

import com.chb.Spring.model.User;
import com.chb.Spring.service.IUserService;

public class UserAction {
    //操作的对象为User
    private User user;
    //存储是由service层执行， service层调用Dao层
    private IUserService userService;
    //删除， load User需要id
    private int id;

    public void add() {
        userService.add(user);
    }

    public void delete() {
        userService.delete(id);
    }

    public void load() {
        userService.load(id);
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public IUserService getUserService() {
        return userService;
    }

    public void setUserService(IUserService userService) {
        this.userService = userService;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

}

3.5测试： 添加一个用户

package com.chb.Spring.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.chb.Spring.action.UserAction;
import com.chb.Spring.model.User;

public class Test {

    @org.junit.Test
    public void test01() {
        ApplicationContext context = new ClassPathXmlApplicationContext("SpringBean.xml");
        //获取UserAction
        UserAction userAction1 = (UserAction) context.getBean(UserAction.class);
        //创建测试用户
        User user = new User(1, "chb");
        //执行操作Action
        userAction1.setUser(user);
        userAction1.add();
    }

}

结果：

4、那么， 什么时候使用单例，什么时候使用多例 4.1、UserDao,没有属性， 使用单例 4.2、UserService 中有UserDao， 但是UserDao使用单例， 所以UserService使用单例 4.3、关注UserAction， 对于UserAction而言，里面的属性的值的状态会根据不同的线程得到不同的值，所以应该使用多例 测试，UserAction使用默认

再看看多例的效果