锐单电子商城 , 一站式电子元器件采购平台!
  • 电话: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注入

 
     
         LOL
         BOB
         COC
     
 

7、Null注入

 

8、Properties注入

 
     
         20190604
         
         小明
     
 

测试结果:

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百科大全!

相关文章