spring学习记录(二)——spring初体验

2、spring初体验

2.1 不使用spring情况下耦合性

在不使用spring的情况下实现一个功能

1、创建userDao接口

package com.zhangjiangbo.dao;

public interface UserDao {

    void getUser();
}

2、创建UserDao实现类

package com.zhangjiangbo.dao.Impl;

import com.zhangjiangbo.dao.UserDao;

public class UserDaoImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("mysql调用了数据库");
    }
}

3、创建UserServer接口

package com.zhangjiangbo.service;

public interface UserService {

    void getUser();
}

4、创建UserServer接口实现类

package com.zhangjiangbo.service.Impl;

import com.zhangjiangbo.dao.UserDao;
import com.zhangjiangbo.service.UserService;

public class UserServiceImpl implements UserService {

    @Override
    public void getUser() {
        UserDao userDao = new UserDaoImpl();
        userDao.getUser();
        System.out.println("获取用户进行业务操作");
    }
}

5、创建测试类

package com.zhangjiangbo;

import com.zhangjiangbo.dao.Impl.UserDaoImpl;
import com.zhangjiangbo.dao.Impl.UserDaoOracle;
import com.zhangjiangbo.service.Impl.UserServiceImpl;
import com.zhangjiangbo.service.UserService;

public class Test {

    @org.junit.Test
    public void test01(){
        UserService userService = new UserServiceImpl();
        userService.getUser();
    }
}

如果我们的userDao实现类文件名需要改动

package com.zhangjiangbo.dao.Impl;

import com.zhangjiangbo.dao.UserDao;

public class UserDaoMysqlImpl implements UserDao {
    @Override
    public void getUser() {
        System.out.println("mysql调用了数据库");
    }
}

在假设我们UserDao接口新增了一个实现类

package com.zhangjiangbo.dao.Impl;

import com.zhangjiangbo.dao.UserDao;

public class UserDaoOracle implements UserDao {

    @Override
    public void getUser() {
        System.out.println("Oracle获取用户数据");
    }
}

这样我们都需要修改原来的代码，每次变动我们都需要修改大量的代码
解决方案：
我们在用到他们的地方写一个接口，利用set方法让用户去创建
修改代码如下：

userService实现类

package com.zhangjiangbo.service.Impl;

import com.zhangjiangbo.dao.UserDao;
import com.zhangjiangbo.service.UserService;

public class UserServiceImpl implements UserService {

    private UserDao userDao;

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

    @Override
    public void getUser() {
        userDao.getUser();
        System.out.println("获取用户进行业务操作");
    }
}

测试类修改

package com.zhangjiangbo;

import com.zhangjiangbo.dao.Impl.UserDaoImpl;
import com.zhangjiangbo.dao.Impl.UserDaoOracle;
import com.zhangjiangbo.service.Impl.UserServiceImpl;

public class Test {

    @org.junit.Test
    public void test01(){
        UserServiceImpl userService = new UserServiceImpl();
        userService.setUserDao(new UserDaoImpl());
        userService.getUser();

        userService.setUserDao(new UserDaoOracle());
        userService.getUser();
    }
}

输出

现在是由我们自行控制创建，吧主动权交给了调用者，程序不取关怎么创建，怎么实现的了，它只提供了一个接口

2.2、Spring初体验(HelloSpring)

现在让我们用spring创建对象试一下，然后修改一下上边的案例

创建maven项目，导入依赖

	<!--核心包-->
	 <dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-webmvc</artifactId>
		<version>5.3.21</version>
	</dependency>
	<!--单元测试包-->
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.13</version>
	 </dependency>
	 <!--lombok工具包-->
	 <dependency>
          <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
           <version>1.18.24</version>
       </dependency>

编写实体类

package com.zhangjiangbo.bean;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {

   private int id;

   private String name;
}

编写spring配置文件

<?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.xsd">

    <bean id="user" class="com.zhangjiangbo.bean.User">
       <property name="id" value="1"/>
       <property name="name" value="张江博"/>
    </bean>
</beans>

编写测试类，测试类中的spring.xml为上边配置文件的文件名

    @org.junit.Test
    public void test02(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        User user = context.getBean("user", User.class);
        System.out.println(user);
    }

输出

2.3 修改案例

熟悉了第一个spring项目，现在我们用spring来写一下上边的案例

编写spring配置文件

<?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.xsd">

    <bean id="userDaoImpl" class="com.zhangjiangbo.dao.Impl.UserDaoImpl"></bean>
    <bean id="userDaoOracle" class="com.zhangjiangbo.dao.Impl.UserDaoOracle"></bean>
    <bean id="userServiceImpl" class="com.zhangjiangbo.service.Impl.UserServiceImpl">
        <property name="userDao" ref="userDaoImpl"/>
    </bean>
</beans>

编写测试类

    @org.junit.Test
    public void test03(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        UserService userService = context.getBean("userServiceImpl", UserService.class);
        userService.getUser();
    }

此时，假设如果我们新增了一个dao接口的实现类，只需要在spring,xml文件中注册bean，在service bean下引用即可，无需修改大量的代码，大大的降低了代码的耦合性
所谓的IOC，一句话搞定：对象有spring来创建，管理，装配！
注意 使用property标签注入是必须要有set方法

2.4 IOC的本质

控制反转(IOC)是一种设计思想，DI(依赖注入)是实现IOC的方法
IOC是spring框架的核心内容，可以使用配置文件，也可以使用注解的方式；来实现IOC
spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时在从IOC容器中取出需要的对象
采用xml方式配置bean的时候，bean的定义信息是和实现分离的，而采用注解的方式可以吧两者合为一体，bean的定义信息直接以注解的形式定义在实现类中，从而打到零配置的目的

控制反转是一种通过描述(xml或注解)并通过第三方去生产活获取特定对象的方式，在spring中实现控制反转是IOC容器，其实现方法是依赖注入(DI)