Spring的简单使用（1）

一：IOC(控制反转)：它是由spring容器进行对象的创建和依赖注入，程序员使用时直接取出即可

正转：例如：

Student stu=new Student（）；

stu.setname("tom");

stu.setAge(20);

在正转中，由程序员自觉来创建对象，给对象注入值。

反转：由spring容器来自动创建对象。在spring.xml文件中如下：

<bean id="stu" class="com.ztb.dao.Student">
    <property name="name" value="tom"></property>
    <property name="age" value="20"></property>
</bean>
标签解释：id指的是创建的对象的名字，class表示要创建的对象在哪个包中的哪个类
property name表示成员变量的名字，value表示给成员变量赋值
给创建的对象赋值的两种方法：

A：使用setter方法注入：

注入分为简单类型注入和引用类型注入：

简单类型注入值使用value属性

引用类型注入值使用ref属性

注意：使用setter注入必须要有set方法和无参构造方法。

简单类型注入：

<bean id="school" class="com.ztb.pojo.School">
    <property name="name" value="海淀大学"></property>
    <property name="address" value="海定区"></property>
</bean>

引用类型注入：

有两个类School和Student，其中Student类中有school的对象：

private String name;
private String age;
private School school;

则引用注入如下：

<bean id="stu" class="com.ztb.pojo.Student">
    <property name="name" value="zhangsan"></property>
    <property name="age" value="20"></property>
    <property name="school" ref="school"></property>
 </bean>

    <bean id="school" class="com.ztb.pojo.School">
        <property name="name" value="海淀大学"></property>
        <property name="address" value="海定区"></property>
    </bean>

B：使用构造方法注入：

a:使用构造方法的参数名称进行注入值：

<bean id="school" class="com.ztb.pojo.School">
    <constructor-arg name="name" value="海鼎"></constructor-arg>
    <constructor-arg name="address" value="海鼎"></constructor-arg>
</bean>

b：使用构造方法参数的下标注入值：

<bean id="student" class="com.ztb.pojo.Student">
    <constructor-arg index="0" value="zhangsan"></constructor-arg>
    <constructor-arg index="1" value="20"></constructor-arg>
    <constructor-arg index="2" ref="school"></constructor-arg>
</bean>

c：使用默认的构造方法的参数的顺序注入值：

<bean id="student1" class="com.ztb.pojo.Student">
    <constructor-arg  value="zhangsan"></constructor-arg>
    <constructor-arg value="20"></constructor-arg>
    <constructor-arg ref="school"></constructor-arg>
</bean>

注意：使用构造方法注入必须要有有参构造方法

二：项目案例：使用三层架构进行用户的插入操作：界面层，业务逻辑层，数据访问层

1非spring接管的三层项目构建：

实体类：User

数据访问层：接口UserMapper，实现类UserMapperImpl

业务逻辑层：接口UserService，实现类UserServiceImpl

实现类中一定要有UserMapper对象，并且接口一定要指向实现类，UserMapper usermapper=new UserMapperImpl;

界面层：实现类UserController

实现类中一定要有UserServicer对象，并且接口一定要指向实现类，UserService userservice=new UserServiceImpl;

2:spring接管的三层项目构建：

实体类：

private Integer uid;
private String uname;
private String uage;

数据访问层：

public class UserMapperImpl implements UserMapper{

    public int insert(User user) {
        System.out.println(user.getUname()+"插入成功");
        return 1;
    }
}

业务逻辑层：

private UserMapper userMapper;

public void setUserMapper(UserMapper userMapper) {
    this.userMapper = userMapper;
}

public int insert(User user) {

    return  userMapper.insert(user);
}

界面层：

 private UserService userService;
 public void setUserService(UserService userService) {
     this.userService = userService;
 }
 public int insert(User user){
    return  userService.insert(user);
}

Spring整合：

<bean id="usermapper" class="com.ztb.dao.UserMapperImpl"></bean>
    <bean id="userservice" class="com.ztb.service.UserServiceImpl">
        <property name="userMapper" ref="usermapper"></property>
    </bean>
    <bean id="usercontroller" class="com.ztb.controller.UserController">
        <property name="userService" ref="userservice"></property>
    </bean>

测试：

 ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserController usercontroller = (UserController) context.getBean("usercontroller");
usercontroller.insert(new User(1,"张三","3"));

spring接管的三层项目构建（使用注解）：

实体类：

private Integer uid;
private String uname;
private String uage;

数据访问层：

@Repository
public class UserMapperImpl implements UserMapper{

    public int insert(User user) {
        System.out.println(user.getUname()+"插入成功");
        return 1;
    }
}

业务逻辑层：

@Service
public class UserServiceImpl implements UserService{
    @Autowired
    private UserMapper userMapper;

    public int insert(User user) {

        return  userMapper.insert(user);
    }
}

界面层：

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    public int insert(User user){
       return  userService.insert(user);
   }

Spring扫描包：

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

测试：

 ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserController usercontroller = (UserController) context.getBean("userController");//因为默认是驼峰命名
usercontroller.insert(new User(1,"张三","3"));

三：基于注解的IOC，也称依赖注入

a：创建对象的注解：

@Component：可以创建任意对象，创建的对象默认名称是类名的驼峰命名法，也可以指定对象的名称

@Component
public class School {
    @Value("海鼎")
    private String name;
    @Value("海定区")
    private String address;

@Controller：专门用来创建控制器的对象（Servlet），这种对象可以接收用户的请求。可以返回处理结果给客户端

@Service：专门用来创建业务逻辑层的对象，负责向下访问数据访问层，处理完毕后的结果返回给界面层

@Repository：专门用来创建数据访问层的对象，负责数据库中的增删改查

注意：使用注解的IOC，需要在spring.xml文件中配置扫描包：

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

b：依赖注入的注解

值类型的注入：

@Value:用来给简单类型注入值：

@Component 创建的对象名默认为school
public class School {
    @Value("海鼎")
    private String name;
    @Value("海定区")
    private String address;

引用类型的注入：

1@Autowired：使用类型注入值，从整个Bean工厂中搜索同源类型的对象进行注入

同源类型：

a：被注入的类型（Student中的school）与注入的类型是完全相同的类型

@Component
public class Student {
    @Value("张三")
    private String name;
    @Value("20")
    private String age;
    @Autowired
    private School school;

@Component 创建的对象名默认为school
public class School {
    @Value("海鼎")
    private String name;
    @Value("海定区")
    private String address;

b：被注入的类型（Student中的school父）与注入的类型是父子类类型

public class Student {
    @Value("张三")
    private String name;
    @Value("20")
    private String age;
    @Autowired
    private School school;

@Component("school1")
public class School {
    @Value("海鼎")
    private String name;
    @Value("海定区")
    private String address;

@Component("school")
public class SubSchool extends School{
    @Value("小海地")
    private String name;
    @Value("小海底")
    private String address;

c：被注入的类型（Student中的school接口）与注入的类型是接口与实现类的类型

注意：在有父子类的情况下，使用按类型注入，就意味着有多个可注入的对象，此时按照名称进行二次筛选，选中与被注入对象相同名称的对象进行注入

2：@Autowired+@Qualifier：使用名称注入值，从整个Bean工厂中搜索相同名称的对象进行注入

a：被注入的类型（Student中的school）与注入的类型是完全相同的类型

@Component("school1")
public class School {
    @Value("海鼎")
    private String name;
    @Value("海定区")
    private String address;

@Component
public class Student {
    @Value("张三")
    private String name;
    @Value("20")
    private String age;
    @Autowired
@Qualifier("school1")
    private School school;

b：被注入的类型（Student中的school父）与注入的类型是父子类类型

@Component
public class Student {
    @Value("张三")
    private String name;
    @Value("20")
    private String age;
    @Autowired
    @Qualifier("school1")
    private School school;

@Component("school1")
public class School {
    @Value("海鼎")
    private String name;
    @Value("海定区")
    private String address;

@Component("school")
public class SubSchool extends School{
    @Value("小海地")
    private String name;
    @Value("小海底")
    private String address;

四：为应用指定多个Spring配置文件：

1：

2：三层架构改造：

在total.xml中：

<import resource="applicationContext_*.xml"></import>汇总

巴特西

Spring的简单使用（1）

最新文章

热门文章