Spring之ioc容器

目录

1.简介

2.为什么学习Spring

3.Spring的核心特性

4.Spring ioc 容器的特点

5.Spring的注入方式

6.web整合容器

1.简介：

Spring简介

   Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。

   Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。

   然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

   目的：解决企业应用开发的复杂性

   功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能

   范围：任何Java应用

   简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

2.为什么学习Spring：

学习Spring框架有以下几个原因：

1. 强大的功能：Spring框架是Java开发中最流行的企业级框架之一，它提供了很多强大的功能和特性，比如依赖注入（DI）、面向切面编程（AOP）、事务管理、RESTful Web服务等。通过学习Spring，你可以更高效地开发Java应用，提高开发效率和质量。

2. 应用广泛：Spring框架在各种规模的企业应用中广泛应用，尤其在Java后端开发中。许多企业都将Spring作为其首选框架，因此学习Spring可以增加你的就业机会和市场竞争力。

3. 解耦和模块化：Spring框架采用了松散耦合的设计理念，可以将应用程序的不同模块解耦，使得应用更加灵活和可维护。通过学习Spring，你可以学会如何设计和开发具有高内聚、低耦合的模块化应用。

4. 社区支持：Spring框架有一个庞大的用户社区，你可以在社区中得到丰富的资源、教程和解决方案。如果遇到问题或困惑，可以向社区寻求帮助和指导。

5. 整合其他框架：Spring框架提供了很多整合其他框架的功能，比如与Hibernate、MyBatis等ORM框架的无缝整合，与Spring MVC、Spring Boot等web框架的集成等。学习Spring可以帮助你更好地理解和利用这些框架。

所以学习Spring框架可以提升你的Java开发技能和就业前景，让你成为一名高效、专业的企业级Java开发者。

3.Spring的核心特性：

Spring框架的核心特性包括：

1. 控制反转（IoC）：Spring通过IoC容器管理对象的依赖关系，将对象的创建、组装和管理交给Spring容器，降低了组件之间的耦合度。

2. 面向切面编程（AOP）：Spring支持AOP，通过动态代理的方式，将横切关注点（如日志、事务等）从业务逻辑中解耦出来，提供了更好的模块化和复用性。

3. 基于注解的配置：Spring提供了丰富的注解，用于配置和管理Bean、依赖注入、事务等，简化了配置文件的编写。

4. 数据访问与集成：Spring提供了对各种持久化技术的支持，如JDBC、ORM框架（如Hibernate、MyBatis）、NoSQL数据库等，并提供了统一的事务管理接口。

5. MVC框架：Spring MVC是基于模型-视图-控制器设计模式的Web框架，提供了灵活的请求处理、视图解析和数据绑定等功能。

6. 安全性：Spring提供了强大的安全性支持，包括认证（Authentication）和授权（Authorization）等机制，可以灵活地保护应用程序资源。

7. 缓存管理：Spring支持对各种缓存技术的集成，如Ehcache、Redis等，提供了缓存抽象层，简化了缓存的使用和管理。

8. 国际化和本地化：Spring提供了对多语言和本地化的支持，可以方便地实现国际化应用程序。

这些都是Spring框架的核心特性，使得Spring成为一个功能强大且灵活的开发框架。

4.Spring ioc 容器的特点：

IoC（Inversion of Control，控制反转）是Spring框架的核心概念之一。IoC容器是Spring框架提供的一个核心模块，负责对象的创建、配置和管理，实现了对象之间的松耦合。

在传统的开发模式中，当一个对象需要依赖其他对象时，该对象需要自行负责创建和管理它所依赖的对象。这种方式会导致大量的依赖关系交织在代码中，增加了代码的复杂性，同时也使得对象的创建和配置过程与核心业务逻辑紧密耦合在一起。

而IoC容器的作用是将这种对象之间的依赖关系的控制权转移到容器中，将对象的创建和配置过程解耦。开发人员只需通过配置文件或注解方式描述对象之间的依赖关系，容器负责根据配置信息进行对象的实例化和依赖注入。这意味着控制权从对象本身转移到了IoC容器，因此称之为"控制反转"。

代码演示：

 

pom.xml配置文件：

  4.0.0

  org.example
  text
  1.0-SNAPSHOT
  war

  text Maven Webapp
  
  http://www.example.com

  
    5.0.1.RELEASE
    4.0.0
    4.12
  
  
    
      junit
      junit
      3.8.1
      test
    
    
    
      org.springframework
      spring-context
      ${spring.version}
    
    
      org.springframework
      spring-aspects
      ${spring.version}
    
    
    
      junit
      junit
      ${junit.version}
      test
    
    
    
      javax.servlet
      javax.servlet-api
      ${javax.servlet.version}
      provided
    
  

  
    text
    
      
        
          maven-clean-plugin
          3.1.0
        
        
        
          maven-resources-plugin
          3.0.2
        
        
          maven-compiler-plugin
          3.8.0
        
        
          maven-surefire-plugin
          2.22.1
        
        
          maven-war-plugin
          3.2.2
        
        
          maven-install-plugin
          2.5.2
        
        
          maven-deploy-plugin
          2.8.2
        
      
    
  

UserService用户更改个人用户的接口

 

UserServiceImpl 实现类

 

 UserServiceImpl1 实现类

 

 UserAction 控制器：

package com.zking.ioc.web;

import com.zking.ioc.service.Impl.UserServiceImpl;
import com.zking.ioc.service.Impl.UserServiceImpl1;
import com.zking.ioc.service.UserService;

/**
 * @author bing人
 * @site
 * @company xy集团
 * @create 2023-08-15 16:18
 *
 * 程序员手动实例化对象的弊端
 * 1.一旦依赖的接口的实现需要大批量改动，迭代，维护成本极高
 * 当接口的实现类不统一，维护成本更高
 */
public class UserAction {
    //如果客户说没有上传头像的功能就修改UserServiceImpl为UserServiceImpl1
    private UserService userService ;

    public UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public String update(){
        userService.update();
        return "list";
    }
}

 GoodsAction控制器:

package com.zking.ioc.web;

import com.zking.ioc.service.Impl.UserServiceImpl;
import com.zking.ioc.service.Impl.UserServiceImpl1;
import com.zking.ioc.service.UserService;

/**
 * @author bing人
 * @site
 * @company xy集团
 * @create 2023-08-15 16:26
 */
public class GoodsAction {
    private UserService userService ;

    public UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public String update(){
        userService.update();
        return "list";
    }
}

 spring-context.xml 配置文件：

Demo1测试类:

package com.zking.ioc.demo;

import com.zking.ioc.web.GoodsAction;
import com.zking.ioc.web.UserAction;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author bing人
 * @site
 * @company xy集团
 * @create 2023-08-15 16:49
 */
public class Demo1 {
    public static void main(String[] args) {
        //加载spring核心配置文件（建模），获取spring的上下文对象，上下文对象中可以获取任何的javebean对象
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-context.xml");
      //强转
        UserAction userAction= (UserAction) context.getBean("userAction");
        userAction.update();
        GoodsAction goodsAction= (GoodsAction) context.getBean("goodsAction");
        goodsAction.update();
    }
}

输出结果：

 5.Spring的注入方式：

set注入 将GoodsAction中的代码修改为：

package com.CloudJun.ioc.web;
 
import com.CloudJun.ioc.service.UserService;
 
import java.util.List;
 
/**
 * @author bing人
 * @site
 * @company xy集团
 * @create 2023-08-16 16:49
 */
public class GoodsAction {
 
 
    /**
     * 例如:在不同的控制器中进行方法调用
     */
    private UserService userService;
    private String gname;//名称
    private int age;//保质期
    private List peoples;//使用人群
 
 
    public String getGname() {
        return gname;
    }
 
    public void setGname(String gname) {
        this.gname = gname;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public List getPeoples() {
        return peoples;
    }
 
    public void setPeoples(List peoples) {
        this.peoples = peoples;
    }
 
    public UserService getUserService() {
        return userService;
    }
 
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
 
 
    public void pop(){
        System.out.println("名称:"+this.gname);
        System.out.println("保证期:"+this.age);
        System.out.println("使用人群:"+this.peoples);
    }
 
 
    public String update(){
        userService.update();
        return "list";
    }

}

修改spring-context.xml 配置文件：

 
 
        
         
 
        
 
        
            
            
            
            
                
                    小红
                    漂亮
                    别个说的
                
            
        
 
        
        

 输出结果：

构造注入：

将UserAction中的所有代码修改为: 

package com.zking.ioc.web;

import com.zking.ioc.service.Impl.UserServiceImpl;
import com.zking.ioc.service.Impl.UserServiceImpl1;
import com.zking.ioc.service.UserService;

import java.util.List;

/**
 * @author bing人
 * @site
 * @company xy集团
 * @create 2023-08-15 16:18
 *
 * 程序员手动实例化对象的弊端
 * 1.一旦依赖的接口的实现需要大批量改动，迭代，维护成本极高
 * 当接口的实现类不统一，维护成本更高
 */
public class UserAction {
    
    private UserService userService ;

    private  String uname;//姓名
    private  int age;//年龄
    private List hobby;//爱好

    public UserAction() {
    }

    public UserAction(String uname, int age, List hobby) {
        this.uname = uname;
        this.age = age;
        this.hobby = hobby;
    }

    public UserService getUserService() {
        return userService;
    }
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public void pop(){
        System.out.println("名字为:"+this.uname);
        System.out.println("年龄为:"+this.age);
        System.out.println("爱好为:"+this.hobby);
    }

    public String update(){
        userService.update();
        return "list";
    }
 

}

输出结果：