锐单电子商城，一站式电子元器件采购平台！

电话：400-990-0325

Spring系列 1.Spring概述及IOP

时间：2023-04-17 09:37:00 iop到fta连接电缆

Spring概述

简介

Spring : 春天 —>给软件行业带来春天

2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。

2004年3月24日，Spring框架以interface在21框架的基础上，经过重新设计，发布了1.0正式版。

很难想象Rod Johnson的学历 , 他是悉尼大学的博士，但他的专业不是计算机，而是音乐。

Spring理念 : 使现有技术更加实用 . 它本身就是一个大杂烩 , 整合现有框架技术

官网 : http://spring.io/

官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/

GitHub : https://github.com/spring-projects

优点

1、Spring免费开源框架 , 容器 .

2、Spring是轻量级框架 , 非侵入式的 .

3、控制反转 IoC , 面向切面 Aop

4.支持事物 , 支持框架

…

一句话总结:

Spring轻量级控制反转(IoC)和面向切面(AOP)容器(框架)。

组成

Spring 由框架组成的分层架构 7 定义良好的模块组成。Spring 在核心容器上构建模块，定义了创建、配置和管理 bean 的方式。

组成 Spring 框架的每个模块(或组件)可以单独存在，也可以与其他一个或多个模块联合实现。每个模块的功能如下:

核心容器：提供核心容器 Spring 框架的基本功能。核心容器的主要部件是BeanFactory，实现工厂模式。BeanFactory 使用控制反转（IOC）该模式将应用程序的配置和依赖性规范与实际应用程序代码分开。
Spring 上下文：Spring 上下文是配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，如 JNDI、EJB、电子邮件、国际化、验证和调度功能。
Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。因此，它很容易使用 Spring 任何支持框架管理的支持 AOP的对象。Spring AOP 模块为基于 Spring 应用程序中的对象提供事务管理服务。通过使用 Spring AOP，声明性事务管理可以集成到应用程序中，无需依赖组件。
Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可以用来管理不同数据库供应商抛出的异常处理和错误信息。异常层次结构简化了错误处理，大大降低了需要编写的异常代码数量(如开关连接)。Spring DAO 的面向 JDBC 异常遵循一般 DAO 层次结构异常。
Spring ORM：Spring 多个框架插入 ORM 提供框架 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵循 Spring 一般事务和 DAO 层次结构异常。
Spring Web 模块：Web 上下文模块基于应用程序上下文模块 Web 应用程序提供上下文。Spring 框架支持与 Jakarta Struts 的集成。Web 该模块还简化了处理多部分请求和将请求参数绑定到域对象的工作。
Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过战略界面，MVC 框架变得高度可配置，MVC 大量的视图技术包括 JSP、Velocity、Tiles、iText 和 POI。

拓展

Spring Boot与Spring Cloud

Spring Boot 是 Spring 基于脚手架的快速配置Spring Boot 个人微服务快速开发；
Spring Cloud是基于Spring Boot实现的；
Spring Boot单个微服务个体专注于快速方便的集成，Spring Cloud注重全局服务治理框架；
Spring Boot使用约束优于配置的概念，许多集成方案已经帮助您选择，可以不配置 , Spring Cloud很大一部分是基于的Spring Boot来实现，Spring Boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring Boot，依赖关系。
SpringBoot在SpringClound如果你想学习，它起着承上启下的作用SpringCloud必须要学习SpringBoot。

IOC理论推导

IoC基础

新的空白maven项目

分析实现

我们先用我们原来的方式写一段代码 .

1、先写一个UserDao接口

public interface UserDao {    public void getUser(); }

2、再去写Dao的实现类

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

3、然后去写UserService的接口

public interface UserService {    public void getUser(); }

4、最后写Service的实现类

public class UserServiceImpl implements UserService {    private UserDao userDao = new UserDaoImpl();     @Override    public void getUser() {        userDao.getUser();   } }

5、测试一下

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

这是我们最初的方式 , 一开始大家都这样写吧？ . 现在我们来修改一下 .

把Userdao增加一个实现类 .

public class UserDaoMySqlImpl implements UserDao {    @Override    public void getUser() {        System.out.println("MySql获取用户数据");   } }

然后我们要用MySql的话 , 我们需要去service在实现类中修改相应的实现

public class UserServiceImpl implements UserService {    private UserDao userDao = new UserDaoMySqlImpl();     @Override    public void getUser() {        userDao.getUser();   } }

在假设, 再加一个Userdao的实现类 .

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

所以我们必须使用它Oracle , 又需要去service在实现类中修改相应的实现 . 假设我们的需求很大 , 这种方法根本不适用，甚至反人类，对吧？ , 每次变动 , 大量代码需要修改 . 这种设计的耦合过高，牵一发，动全身 .

那我们该怎么解决呢？ ?

我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用set , 我们去代码中修改 .

public class UserServiceImpl implements UserService {    private UserDao userDao; // 利用set实现    public void setUserDao(UserDao userDao) {        this.userDao = userDao;   }     @Override    public void getUser() {        userDao.getUser();   } }

现在去我们的测试类 , 进行测试 ;

@Test public void test(){    UserServiceImpl service = new UserServiceImpl();    service.setUserDao( new UserDaoMySqlImp() );
   service.getUser();
   //那我们现在又想用Oracle去实现呢
   service.setUserDao( new UserDaoOracleImpl() );
   service.getUser();
}

大家发现了区别没有 ? 可能很多人说没啥区别 . 但是同学们 , 他们已经发生了根本性的变化 , 很多地方都不一样了 . 仔细去思考一下 , 以前所有东西都是由程序去进行控制创建 , 而现在是由我们自行控制创建对象 , 把主动权交给了调用者 . 程序不用去管怎么创建,怎么实现了 . 它只负责提供一个接口 .

这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现 . 耦合性大大降低 . 这也就是IOC的原型 !

IOC本质

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IOC的一种方法，也有人认为DI只是IOC的另一种说法。没有IOC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

依赖注入（DI）

概念

依赖注入（Dependency Injection,DI）。
依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 .
注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 .

构造器注入

我们在之前的案例已经讲过了

Set 注入（重点）

要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is .

测试pojo类 :

Address.java

 public class Address {
 
     private String address;
 
     public String getAddress() {
         return address;
    }
 
     public void setAddress(String address) {
         this.address = address;
    }
 }

Student.java

 package com.kuang.pojo;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
 
 public class Student {
 
     private String name;
     private Address address;
     private String[] books;
     private List hobbys;
     private Map card;
     private Set games;
     private String wife;
     private Properties info;
 
     public void setName(String name) {
         this.name = name;
    }
 
     public void setAddress(Address address) {
         this.address = address;
    }
 
     public void setBooks(String[] books) {
         this.books = books;
    }
 
     public void setHobbys(List hobbys) {
         this.hobbys = hobbys;
    }
 
     public void setCard(Map card) {
         this.card = card;
    }
 
     public void setGames(Set games) {
         this.games = games;
    }
 
     public void setWife(String wife) {
         this.wife = wife;
    }
 
     public void setInfo(Properties info) {
         this.info = info;
    }
 
     public void show(){
         System.out.println("name="+ name
                 + ",address="+ address.getAddress()
                 + ",books="
        );
         for (String book:books){
             System.out.print("<<"+book+">>\t");
        }
         System.out.println("\n爱好:"+hobbys);
 
         System.out.println("card:"+card);
 
         System.out.println("games:"+games);
 
         System.out.println("wife:"+wife);
 
         System.out.println("info:"+info);
 
    }
 }

1、常量注入

测试：

 @Test
 public void test01(){
     ApplicationContext context = newClassPathXmlApplicationContext("applicationContext.xml");
 
     Student student = (Student) context.getBean("student");
 
     System.out.println(student.getName());
 
 }

2、Bean注入

注意点：这里的值是一个引用，ref

3、数组注入

4、List注入

5、Map注入

6、set注入

7、Null注入

8、Properties注入

测试结果：

p命名和c命名注入

User.java ：【注意：这里没有有参构造器！】

 public class User {
     private String name;
     private int age;
 
     public void setName(String name) {
         this.name = name;
    }
 
     public void setAge(int age) {
         this.age = age;
    }
 
     @Override
     public String toString() {
         return "User{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 '}';
    }
 }

1、P命名空间注入 : 需要在头文件中加入约束文件（实体类中要有无参构造器）

 导入约束 : xmlns:p="http://www.springframework.org/schema/p"

2、c 命名空间注入 : 需要在头文件中加入约束文件（在实体类中要有有参构造）

 导入约束 : xmlns:c="http://www.springframework.org/schema/c"

发现问题：爆红了，刚才我们没有写有参构造！

解决：把有参构造器加上，这里也能知道，c 就是所谓的构造器注入！

测试代码：

 @Test
 public void test02(){
     ApplicationContext context = newClassPathXmlApplicationContext("applicationContext.xml");
     User user = (User) context.getBean("user");
     System.out.println(user);
 }

Bean的创建方式：

1.构造方法实例化

2.静态工厂实例化：在类中创建public static 方法，然后再xml中配置id，class，factory_method

3.实例工厂实例化：在类中创建普通方法，里面返回new 类名，然后再xml中配置id，class，bean id（方法名），factory_bean（上面的第一个id），factory_method

后序还有Spring的相关文章！

锐单商城拥有海量元器件数据手册、IC替代型号，打造电子元器件IC百科大全！