【Spring】spring简介 + ioc理论 + helloSpring

Spring

spring理念：让现有的技术更加容易使用，本身就是一个大杂烩，可以整合一大堆东西，例如Mybatis，javaWeb之类的
官网： https://spring.io/projects/spring-framework#overview

我们在导Spring依赖的pom的时候，可以直接导spring-webmvc里面包含了大部分东西，然后再导一个jdbc

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-webmvcartifactId>
    <version>5.2.5.RELEASEversion>
dependency>

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-jdbcartifactId>
    <version>5.2.3.RELEASEversion>
dependency>
1
2
3
4
5
6
7
8
9
10
11
12

• spring是开源的免费的容器
• spring是一个轻量级的，非侵入式的
• ioc，aop
• 支持事务处理，对框架整合的支持
• spring是一个轻量级的ioc和aop的框架

IOC理论

在之前，用户的需求可能回影响原来的代码；因为之前是主动创建对象，控制权在程序员手上，因此我们可以使用set，被动接受对象，用户想如何更新就如何更新。

现在的场景是，我们有多种dao的方式，但随着用户的需求变化，我们的dao的方式可能要改变，因此我们不能写死
我们可以通过ioc的方式，自己扩展dao的实现方式，然后在service层让用户自己传入相关的userDao实体类，这个就相当于把控制权让给了用户了

UserDao：

package com.hou.dao;

public interface UserDao {
    void getUser();

}
1
2
3
4
5
6

假设我们的UserDao实现类都是实现一个getUser方法

UserService：

package com.hou.service;

public interface UserService {
    void getUser();
}
1
2
3
4
5

UserService也是一样，还是实现一个getUser，不过这个getUser可能是调用某个UserDao实现类的方法，我们可以看看它的实现类：

UserServiceImpl：

package com.hou.service;

import com.hou.dao.UserDao;
import com.hou.dao.UserDaoImp;

public class UserServiceImp implements UserService{

    private UserDao userDao;

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

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

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

这里就是通过set方法注入一个bean对象，然后调用这个对象的getUser即可

beans.xml

<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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userdaomysql" class="com.hou.dao.UserDaoMysqlImpl">bean>

    <bean id="userServiceImpl" class="com.hou.service.UserServiceImp">
        
        
        <property name="userDao" ref="userdaomysql"/>
    bean>

beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

我们这里要创建每个对象的bean
可以看到我们来了一个userdaomysql的bean，注意这里要写一个class就是它所在的目录
然后我们要把这个userdaomysql注入导userSericeImpl的set方法里面，这个name对应的应该是UserServiceImpl里面的真实属性名 ref的话就是需要引用的bean 就是上面这个

用户调用方法

import com.hou.service.UserServiceImp;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    public static void main(String[] args) {
        ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("beans.xml");

        UserServiceImp userServiceImp = (UserServiceImp) classPathXmlApplicationContext.getBean("userServiceImpl");

        userServiceImp.getUser();

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

1.首先通过ClassPathXmlApplicationContext(“beans.xml”)获取配置文件
2.在配置文件中通过getbean获取一个UserServiceImp实现类（这里面注入的是sqldao的）
3.最后调用它的getUser方法，实际上调用的就是sqlDao的getUser方法
结果如下：

HelloSpring

POJO（Plain Ordinary Java Object）简单的Java对象
我们先构建一个pojo 就是getset String

package com.hou.pojo;

public class Hello {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "name='" + name + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

然后我们在xml给它注入一些属性，比如说这里的name设置一下

<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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    
    
    
    

    <bean id="hello" class="com.hou.pojo.Hello">
        <property name="name" value="Spring"/>
    bean>

beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

可以看到id是用来唯一表示bean的 class就是文件的位置
property就是完善bean的属性
如果是name的话要和pojo真实的属性名称对齐，然后Value要赋予其相关类型的值

然后测试一下：

import com.hou.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Mytest {


    public static void main(String[] args) {
        //获取spring上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //我们的对象下能在都在spring·中管理了，我们要使用，直接取出来就可以了
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

思想还是一样，抽出配置文件，然后获取bean，最后调用一下这个bean的toString（注意，这时候已经是赋值了Spring的了）

总结

ioc就是把控制权从程序员手中让给用户
也就是不把代码写死
可以灵活地更改对象
对象用bean，具体地值都在bean里面配好了
用户直接通过xml取bean，然后直接调用方法即可