1.spring简介

• Spring：春天------> 给软件行业带来了春天！
• SSH ： Struct2 + Spring + Hibernate！
• SSM ： SpringMvc + Spring + Mybatis！

2.开发思路(控制反转)

传统new对象的逻辑开发思路：
dao/mapper–>daoImpl/mapperImpl–>service–>serviceImpl

1.用传统思路写出一个,主动权在程序员

1. 创建一个普通Maven项目
   
2. 建立dao包，创建接口写实现类，需要注意的是，接口必须与实现类的上一级目录同级

public interface UserMapper {
    public void getUser();
}

import com.yang.dao.UserMapper;

public class UserMapperImpl implements UserMapper {
    public void getUser() {
        System.out.println("获取用户数据");
    }
}

3. 编写用户业务层，业务层的本质就是调用dao层（获取数据）

public interface UserService {
    public void getUser();
}

4. 编写业务层的实现类，需要注意的是，接口必须与实现类的上一级目录同级

public class UserServiceImpl implements UserService {

private  UserMapper userMapper = new UserMapperImpl();
    public void getUser(){
        userMapper.getUser();
    }
}

5. 测试

<!--导入对应依赖-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

@Test
public void test(){
    UserServiceImpl service = new UserServiceImpl();
    service.getUser();
}

2.现如今，控制反转，主动权在用户，提供对外程序

要改的是UserServiceImpl和 测试类

public class UserServiceImpl implements UserService {

    //不去写死,对外提供接口
    private UserMapper userMapper;

   //对外提供接口,程序不用管理实现  set方法!

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

    public void getUser() {
        userMapper.getUser();
    }
   
}

你想要使用哪种实现类,只需要在测试类里面更改实现类,主动权到了用户手里面

    public void test1(){
       UserMapperImpl userMapper = new UserMapperImpl();
//        UserMapper userMapper = new UserMapperMySqlImpl();
//        UserOracleImpl userMapper = new UserOracleImpl();

        UserServiceImpl userService = new UserServiceImpl();
        <!--精华在这里,用户可以通过改变业务层的代码来实现程序更改-->
        userService.setUserMapper(userMapper);

        userService.getUser();

    }

3.Hello,Spring的实现

需要新建一个Manven项目
hello 对象创建和赋值都是Spring进行的
程序不控制对象的创建，被动的接受
Spring IOC容器，控制反转的思想
SpringIOC的具体实现，DI（依赖注入，set方法）

1. 导入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.1.9.RELEASE</version>
</dependency>

2. 编写XML配置文件

        <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

</beans>

3. 在pojo类编写Hello类

4. 注册到bean

<!--相当于 Hello hello = new  Hello();
           hello.setName("Spring);
           创建了一个对象hello ,他的名字叫Spring-->
<bean id="hello" class="com.yang.pojo.Hello">
    <property name="name" value="Spring"/>
</bean>

5. 测试

public void testHelloSpring() {
    //解析applicationContext.xml文件，Spring会自动将里面的bean注册到IOC容器中
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    Hello hello = (Hello)context.getBean("hello");
    hello.show();
    //hello 对象创建和赋值都是Spring进行的
    //程序不控制对象的创建，被动的接受
    //Spring IOC容器，控制反转的思想
    //SpringIOC的具体实现，DI（依赖注入，set方法）
}

6. 注意，这里只能存在一个spring