Spring系列 1.Spring概述及IOP
时间:2023-04-17 09:37:00
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的相关文章!