Spring详解(一)概述和 IoC控制反转

文章目录

• Spring
• • 第一章 Spring 概述
  • • 1.1. 什么是spring
    • 1.2 spring的地址
    • 1.3 Spring优点
  • 第二章 IoC 控制反转
  • • 2.1 IoC 概念
    • 2.2 Spring的配置文件
    • 3.Spring 容器创建对象的特点
    • 4.DI：给属性赋值
    • • 4.1基于xml的DI
      • • 1）set注入，也叫作设值注入
        • 2)构造注入（理解）
        • 3)引用类型的自动注入
        • 4）作业 IoC
        • 5)项目中使用多个Spring配置文件
      • 4.2基于注解的DI（注解为主，配置文件为辅）
      • • 4.21注解使用的核心步骤
        • 4.22注解介绍
        • @Component
        • 多个包扫描直接的配置文件
        • 4.23简单属性的赋值@Value
        • 4.24配置文件赋值
        • 4.25@Autowired 注解byType方法
        • 4.26@Autowired 注解byName方法
        • 4.27 @Resource
    • 5.总结
    • 5.总结

Spring 第一章 Spring 概述 1.1. 什么是spring

​ spring就是一个java框架，使用java语言开发的， 轻量级的， 开源的框架。 可以在j2se、j2ee项目中都可以使用。

​ spring核心技术： ioc， aop

​ spring又叫做：容器， spring作为容器， 装的是java对象。 可以让spring创建java对象， 给属性赋值。

​ spring作用： 实现解耦合， 解决java对象之间的耦合， 解决模块之间的耦合。

​ tomcat也是容器：管理的是servlet， listener， filter等对象。

​ 创建HelloServlet 类， 写web.xml

​ spring：创建SomeServiceImpl, 写spring的配置文件。

​

1.2 spring的地址

​ https://spring.io

1.3 Spring优点

​ Spring 是一个框架，是一个半成品的软件。有 20 个模块组成。它是一个容器管理对象，容器是装东西的，Spring 容器不装文本，数字。装的是对象。Spring 是存储对象的容器。
（1） 轻量
​ Spring 框架使用的 jar 都比较小，一般在 1M 以下或者几百 kb。Spring核心功能的所需的 jar 总共在 3M 左右。
Spring 框架运行占用的资源少，运行效率高。不依赖其他 jar

（2） 针对接口编程，解耦合
Spring 提供了 Ioc 控制反转，由容器管理对象，对象的依赖关系。原来在程序代码中的对象创建方式，现在由容器完成。对象之间的依赖解耦合。

（3） AOP 编程的支持
通过 Spring 提供的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付在 Spring 中，开发人员可以从繁杂的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

（4） 方便集成各种优秀框架
Spring 不排斥各种优秀的开源框架，相反 Spring 可以降低各种框架的使用难度，Spring 提供了对各种优秀框架（如 Struts,Hibernate、MyBatis）等的直接支持。简化框架的使用。Spring 像插线板一样，其他框架是插头，可以容易的组合到一起。需要使用哪个框架，就把这个插头放入插线板。不需要可以轻易的移除。

第二章 IoC 控制反转 2.1 IoC 概念

​ IoC，Inversion of Control ： 控制反转， 是一个理论，一个指导思想。 指导开发人员如何使用对象，管理对象的。 把对象的创建，属性赋值，对象的声明周期都交给代码之外的容器管理。

1. IoC分为 控制和反转

​ 控制： 对象创建，属性赋值， 对象声明周期管理

​ 反转：把开发人员管理对象的权限转移给了代码之外的容器实现。 由容器完成对象的管理。

​ 正转：开发人员在代码中， 使用 new 构造方法创建对象。 开发人员掌握了对象的创建，属性赋值，对象从开始到销毁的全部过程。 开发人员有对 对象 全部控制。

​

​ 通过容器，可以使用容器中的对象（容器已经创建了对象， 对象属性赋值了， 对象也组装好了）。

​ Spring就是一个容器，可以管理对象，创建对象，给属性赋值。

2. IoC的技术实现

   DI （ 依赖注入） ：Dependency Injection， 缩写是DI . 是IoC的一种技术实现。 程序只需要提供要使用的对象的名称就可以了， 对象如何创建， 如何从容器中查找，获取都由容器内部自己实现。

​ 依赖名词： 比如说ClassA类使用了ClassB的属性或者方法，叫做ClassA依赖ClassB.

public class ClassB{
    
    public void createOrder(){}
}

public class ClassA{
    //属性
    private ClassB  b = new ClassB();
    
    public void buy(){
        b.createOrder();
    }
}

执行ClassA的buy()
ClassA a  = new ClassA();
a.buy();

3. Spring框架使用的DI实现IoC.

   通过spring框架， 只需要提供要使用的对象名词就可以了。 从容器中获取名称对应的对象。

spring底层使用的 反射机制， 通过反射创建对象，给属性。

2.2 Spring的配置文件

    



spring标准的配置文件：
1）根标签是 beans
2)beans 后面的是约束文件说明
3)beans里面是bean声明。
4）什么是bean:bean就是对象，spring容器管理的java对象，叫做bean。

3.Spring 容器创建对象的特点

1.容器对象ApplicationContext：接口

​ 通过ApplicationContext对象，获取要使用的其他java对象，执行getBean(“的id”)

2. spring默认是调用类的无参数构造方法，创建对象。
3. spring读取配置文件，一次创建好所有对象，都放到容器的map中。

src/main/resources/beans.xml （熟练掌握后用其他的名字）

​ 改变传统思想，要从容器中拿对象去用。

  
    @Test
    public void test04(){
        String config = "beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

//        获取容器中定义的对象的数量
        int nums = ctx.getBeanDefinitionCount();
        System.out.println("容器中定义对象的数量=="+nums);

//        获取容器中定义的对象名称
        String names[] = ctx.getBeanDefinitionNames();
        for (String name:names){
            System.out.println("容器中对象的名称 ==="+name);
        }
    }
    
    @Test
    public void test05(){
        String config = "beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        Date date = (Date) ctx.getBean("mydate");
        System.out.println("date==="+date);

        OtherService service = (OtherService) ctx.getBean("otherService");
        service.doOther();
    }

4.DI：给属性赋值

​ Spring调用类的无参数构造方法，创建对象。对象创建后给属性赋值。

​ 给属性赋值可以使用1）xml配置文件的标签和属性；2）使用注解。

DI的分类：1.set注入，也叫做设值注入；2.构造注入。

4.1基于xml的DI

​ 在xml配置文件中使用标签和属性，完成对象的创建，属性赋值。

1）set注入，也叫作设值注入

​ 概念：spring调用类中的set方法，在set方法中可以完成属性的赋值。推荐使用 applicationContext.xml

简单类型的设值注入，使用value
    
        
        
    

        DI:给属性赋值
        简单类型:java中的基本数据类型和String
        1.set注入:spring调用类的set方法,通过set方法完成属性赋值
          简单类型的set注入:
          语法: 
                    
                    ....
               
        2.set注入：
           引用类型的set注入：
           语法：
                    
                    ...
                

​ 建议使用name的方式，可读性更高。

2)构造注入（理解）

​ 构造注入：spring调用类中的有参数构造方法，在创建对象的同时，给属性赋值

构造注入，使用index

创建文件对象

public class MyTest03 {
    @Test
    public void test01(){
        String config ="ba03/applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);

        Student student =(Student) ctx.getBean("myStudent3");
        System.out.println("student=="+student);

        //获取File对象
        File file = (File) ctx.getBean("myFile");
        System.out.println("file==="+file.getName());
    }
}

​

3)引用类型的自动注入

概念：spring可以根据某些规则给引用类型完成赋值。只对引用类型有效。规则byName，byType。

①：byName(按名称注入)：java类中引用类型属性名称和Spring容器中bean的id名称一样的，且数据类型也是一样的，这些bean能够赋值给引用类型。

②：byType(按类型注入)：java类中引用类型的数据类型和Spring容器中bean的class值是同源关系的，这样的bean赋值给引用类型。

        2.byType(按类型注入)：java类中引用类型的数据类型和bean的class是同源的。
                            这些bean能够赋值给引用类型。
        同源关系：
            1.java中引用类型的数据类型和bean的class值是一样的。
            2.java中引用类型的数据类型和bean的class值是父子类关系的。
            3.java中引用类型的数据类型和bean的class值是接口和实现类关系的。
        语法：
            
                简单类型属性赋值
            

            注意：在xml配置文件中，符合条件的对象，只能有一个。
                 多于一个会报错

-->


    
         
        
        
    








    
        
        
    

4）作业 IoC

需求：模拟一用户注册操作。

​ 需要定义一个dao接口（UserDao）接口中的方法 insertUser(SysUser user ) , 定义接口的实现类 MySqlUserDao

inserUser()方法里面不需要操作数据， 输出“使用了dao执行insert操作”。

​ 需要定义一个service接口（UserService)，定义接口的实现类 UserServiceImpl. 在service的实现类有一个 UserDao类型的属性。 service类中有一个方法 addUser(SysUser user).

​ 操作是 service类中的addUser() { userDao.insertUser() } 完成注册。

​ 定义一个实体类 SysUser， 表示用户的数据。

要求实现：

程序中的UserServiceImpl,  MySqlUserDao这些类都有spring容器创建和管理， 同时要给 UserServiceImpl类中的 userDao属性赋值。    从spring容器中获取  UserServiceImpl类型的对象， 调用addUser()方法，输出“使用了dao执行insert操作”。

    @Test
    public void test01(){
        String config ="dao/applicationContext.xml";
        ApplicationContext cxt = new ClassPathXmlApplicationContext(config);

        SysUser user = (SysUser) cxt.getBean("sysuser");

        UserServiceImpl userService =(UserServiceImpl) cxt.getBean("userService");
        userService.addUser(user);
    }

5)项目中使用多个Spring配置文件

​ 分多个配置文件的方式

①按功能模块分，一个模块一个配置文件。

②按类的功能分，数据库操作相关的类在一个文件，service类在一个配置文件，配置redis，事务等等的一个配置文件。

​ Spring管理多个配置文件，常用的是包含关系的配置文件、项目中有一个总的文件，里面有import标签包含其他多个配置文件。

语法：

总的文件



关键字“classpath”:表示类路径，也就是类文件（class文件）所在的目录。Spring到类路径中加载文件什么时候使用						classpath:在一个文件中要使用其他的文件，需要使用classpath。

4.2基于注解的DI（注解为主，配置文件为辅）

基于注解的DI：使用spring提供的注解，完成java对象的创建，属性赋值。

4.21注解使用的核心步骤

1.在源代码加入注解，例如@Component。

2.在Spring的配置文件，加入组件扫描器的标签。

4.22注解介绍

1.创建对象的注解

@Component

@Respository

@Service

@Controller

2.简单类型属性赋值

@Value

3.引用类型赋值

@Autowired:spring提供的注解，支持byName,byType

​ @Autowired：默认就是byType

​ @Autowired @Qualifier:使用byName

@Resource:来自jdk中的注解，给引用类型赋值的，默认是byName

​ @Resource:先使用byName，在byType

​ @Resource(name=“bean的名称”)：只使用byName注入。

@Component

//使用value 指定对象的名称。
//@Component(value = "myStudent")
//省略value
@Component("myStudent")
//    没有提供自定义对象名称，使用框架的默认独享名称：类名首字母小写。
//@Component
public class Student {

多个包扫描直接的配置文件

4.23简单属性的赋值@Value

​ 这个只是基本的使用格式，还可以外部提供值。

    
    @Value(value = "李四")
    private String name;

    private int age;

    public Student(){
        System.out.println("Student 无参数构造方法");
    }

    public void setName(String name) {
        this.name = name;
    }
    @Value(value = "20")
    public void setAge(int age) {
        System.out.println("setAge===="+age);
        this.age = age;
    }

4.24配置文件赋值

​ resources文件下新建 myconf.properties。在applicationContext.xml文件中配置。

    @Value("${myname}")
    @Value(value = "${myage}")

4.25@Autowired 注解byType方法

    
    //默认使用byType
    @Autowired
    private School school;

4.26@Autowired 注解byName方法

    
    //byName
    @Autowired
    @Qualifier(value = "myschool")
    private School school;

推荐用true @Autowired

     *          属性：required:boolean类型的属性，默认为true
     *               true:spring在启动的时候，创建容器对象的时候，会检查引用类型是否赋值成功。
     *                    如果赋值失败，终止程序执行，并报错。
     *               false:引用类型赋值失败，程序正常执行，不报错。引用类型的值是null
	//byName
    @Autowired(required = false)
    @Qualifier(value = "myschoolaaa")
    private School school;

4.27 @Resource

    
    //默认byName自动注入
    //先使用byName赋值，如果赋值失败，再使用byType.
    //本例是byType赋值成功
    @Resource
    private School school;

    //只用byName自动注入

    @Resource(name = "mySchool")
    private School school;

5.总结

​ loC:管理对象的，把对象放在容器中，创建，赋值，管理依赖关系。

​ loC:通过管理对象，实现解耦合。loC解决处理业务逻辑对象之间的耦合关系，也就是service和dao之间的解耦合。

spring作为容器适合管理什么对象：

1）service对象，dao对象。

2）工具类对象

不适合交给spring的对象？

1）实体类。比如动态的对象，用户输入的信息创建的对象，mybatis查出来的对象。

2）servlet，listener，filter等web中的对象。他们是tomcat创建和管理的。

• •   javax.annotation
    

  •   javax.annotation-api
    

  •   1.3.2
    

  • */
    //默认byName自动注入
    //先使用byName赋值，如果赋值失败，再使用byType.
    //本例是byType赋值成功
    @Resource
    private School school;

```java
    //只用byName自动注入

    @Resource(name = "mySchool")
    private School school;

5.总结

​ loC:管理对象的，把对象放在容器中，创建，赋值，管理依赖关系。

​ loC:通过管理对象，实现解耦合。loC解决处理业务逻辑对象之间的耦合关系，也就是service和dao之间的解耦合。

spring作为容器适合管理什么对象：

1）service对象，dao对象。

2）工具类对象

不适合交给spring的对象？

1）实体类。比如动态的对象，用户输入的信息创建的对象，mybatis查出来的对象。

2）servlet，listener，filter等web中的对象。他们是tomcat创建和管理的。