Spring5
1.Spring
1.1简介
-
Spring:春天 --->给软件行业带来了春天
-
2002，首次推出了Spring框架的雏形: interface21框架!
-
Spring框架即以interface21框架为基础，经过重新设计,并不断丰富其内涵,于2004年3月24日发布了1.0正式
版。 -
Rod Johnson，Spring Framework创始人，著名作者。很难想象Rod Johnson的学历，真的让好多人大吃一
惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。 -
Spring理念: 使现有的技术更加容易使用,本身就是一个大杂烩,整合了现有的技术框架！
-
SSH : Struct2 + Spring + Hibernate !
-
SSM : SpringMvc + Spring + Mybatis!
官网: https:/spring.io/projects/spring-framework#overview
官方下载地址: http:/repo.spring.io/release/org[springframework/spring
GitHub: https://github.com/spring-projects/spring-framework
导入maven
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.9</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.9</version>
</dependency>
1.2、优点
- Spring是一个开源的免费的框架(容器)!
- Spring是一个轻量级的、非入侵式的框架!（只要下载下来就可以使用了，非入侵式的就是引入spring不会改变我们原来代码的任何情况，不会对原来项目产生影响）
- 控制反转(IOC) ，面向切面编程(AOP)!
- 支持事务的处理，对框架整合的支持!
总结一句话: Spring就是一个轻量级的控制反转(IOC)和面向切面编程的框架!
1.3、组成
支撑所有基础的是core。
1.4、拓展
在Spring的官网有这个介绍:现代化的Java开发!说白就是基于Spring的开发!
- Spring Boot
1.一个快速开发的脚手架。
2.基于SpringBoot可以快速的开发单个微服务。
3.约定大于配置。 - Spring Cloud
1.SpringCloud是基于SpringBoot实现的。
因为现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC!承上启下的作用!
弊端:发展了太久之后，违背了原来的理念!配置十分繁琐，人称:”配置地狱“!
2、IOC理论推导
IOC本质
控制反转loC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现loC的一种方法，也有人认为DI只是loC的另一种说法。没有loC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是:获得依赖对象的方式反转了。
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是loC容器，其实现方法是依赖注入(Dependency Injection,Dl)。
预备工作具体步骤：
1.新建一个maven空白项目：
2.导入jar包
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.9</version>
</dependency>
导入这一个mvc可以导入自动很多包
3.删除src
新建module
1.UserDao接口
public interface UserDao {
void getUser();
}
2.UserDaolmpl实现类
public class UserDaoImpl implements UserDao {
public void getUser() {
System.out.println("获取用户数据!");
}
}
3.UserService 业务接口
public interface UserService {
void getUser();
}
4.UserServicelmpl 业务实现类
public class UserServiceImpl implements UserService{
// private UserDao userDao = new UserDaoMysqlImpl();
private UserDao userDao;
// set
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
/*
我们使用一个set接口实现,已经发生了革命性的变化!
之前,程序员是主动创建对象!控制权在程序员手上!
使用了set注入之后,程序不再具有主动性,而是变成了被动的接受对象!
这种思想,从本质上解决了问题,我们程序员不用再去管理对象的创建了.
系统的耦合性大大降低,可以更加专注的在业务的实现上!这是IOC的原型!
*/
public void getUser() {
userDao.getUser();
}
public class UserDaoMysqlImpl implements UserDao {
public void getUser() {
System.out.println("MySQL获取用户数据!");
}
}
测试类
public class MyTest {
public static void main(String[] args) {
// 用户实际调用的是业务层,dao层不需要接触
UserService userService = new UserServiceImpl();
// ((UserServiceImpl) userService).setUserDao(new UserDaoImpl());
((UserServiceImpl) userService).setUserDao(new UserDaoMysqlImpl());
userService.getUser();
}
}
在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码!如果程序代码量十分大，修改一次的成本代价十分昂贵!
private UserDao userDao = new UserDaoImpl()
我们使用一个Set接口实现.（已经发生了革命性的变化）
//用set进行动态实现值的注入
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
- 之前，程序是主动创建对象！控制权在程序猿手上
- 使用set注入后，程序不再具有主动性，而是变成了被动的接受对象
//用户实际调用的是业务层，dao层他们不需要接触
UserServiceImpl userService = new UserServiceImpl();
userService.setUserDao(new UserDaoMysqlImpl());
//真正输出的是dao
userService.getUser();
控制反转（IOC）这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低，可以更加专注在业务的实现上！（IOC的原型）
3.HelloSpring
Hello 对象是谁创建的?
hello对象是由Spring创建的
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--使用spring来创建我们的对象,在spring中这些都成为Bean-->
<!--
类型 变量名 = new 类型();
Hello hello = new Hello();
id = 变量名
class = new 对象；
property 相当于给对象中的属性设置一个值
-->
<bean id="Hello" class="com.sgc.pojo.Hello">
<property name="str" value="spring"/>
</bean>
</beans>
Hello 对象的属性是怎么设置的?
hello对象的属性是由Spring容器设置的
这个过程就叫控制反转:
控制:谁来控制对象的创建,传统应用程序的对象是由程序本身控制创建的, 使用Spring后,对象由Spring来创建的
这里的容器就是beans 。
反转:程序本身不创建对象,而变成被动的接受对象
依赖注入:就是利用set方法来进行注入的🔽
beans.xml中的<property name="str" value="spring"/>对应Hello实体类中的这个方法，不能删除这个set方法
public void setStr(String str) {
this.str = str;
}
IOC是一种编程思想,由主动的编程变成被动的接收
我们可以配置一下beans
<bean id="mysqlImpl" class="com.sgc.dao.UserDaoMysqlImpl"/>
<bean id="oracleImpl" class="com.sgc.dao.UserDaoOracleImpl"/>
<bean id ="UserServiceImpl" class="com.sgc.service.UserServiceImpl">
<!--
ref ：就是spring容器中创建好的对象
value：具体的值，基本数据类型-->
<property name="userDao" ref="mysqlImpl"></property>
</bean>
以后不需要再新建一个对象了，直接获取ApplicationContext
public static void main(String[] args) {
//获取ApplicationContext,通过类路径下面的xml去获取:拿到spring的容器
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//容器在手，天下我有，需要什么就直接get什么
UserServiceImpl userServiceImpl =(UserServiceImpl) context.getBean("UserServiceImpl");
userServiceImpl.getUser();
}
现在我们不用再程序中去改动了,要实现不同的操作,只需要在xml配置文件中进行修改IOC可以一句话概括:对象由Spring来创建,管理,装配
4、IOC创建对象的方式
1.默认使用无参构造创建对象,如果没有则报错
2.假设要使用有参构造创建对象
1.直接通过参数来设置
<bean id="user" class="com.liqiliang.pojo.User">
<!--默认无参构造创建对象-->
<!-- <property name="name" value="张三"/> -->
<!--有参构造创建对象, 直接通过参数来设置-->
<constructor-arg name="name" value="王二麻"/>
</bean>
2.下标赋值
<bean id="user" class="com.liqiliang.pojo.User">
<!--有参构造创建对象,下标赋值-->
<constructor-arg index="0" value="李启亮"/>
</bean>
3.通过类型创建
<bean id="user" class="com.liqiliang.pojo.User">
<!--默认无参构造创建对象-->
<!-- <property name="name" value="张三"/> -->
<!--有参构造创建对象,第二种:通过类型创建-->
<!--不建议使用,如果有参构造两个都是String咋整?-->
<!--<constructor-arg type="java.lang.String" value="李四"/>-->
</bean>
User类:
package com.sgc.pojo;
public class User {
private String name;
public User() {
System.out.println("User的无参构造");
}
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("name="+name);
}
}
测试类：
public class MyTest {
public static void main(String[] args) {
// User user = new User();
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//在getbean的时候对象就已经被创建出出来了
User user =(User)context.getBean("user");
user.show();
}
}
在我们创建bean的时候这个对象实例就已经被创建了，比如说我们编写了一个UserT在beans里面进行注册，但是并没有对其进行配置。
<bean id="userT" class="com.sgc.pojo.UserT">
</bean>
会发现虽然没有进行配置但是spring会默认帮我们创建
总结:在配置文件加载的时候, 容器中管理的对象就已经初始化了
5.Spring的配置
5.1 别名alias
<!--别名，如果添加了别名，我们也可以使用别名获取到这个对象-->
<alias name="user" alias="utaha" />
测试类的使用:可以使用别名获得这个对象
User user =(User)context.getBean("utaha");
5.2 bean的配置
<!--
id : bean 的唯一标识符，也就是我们学的对象名
class : bean 对象所对应的全限定名:包名+类名
name : 也是别名，而且 name 更高级，可以同时取多个别名
-->
<bean id="userT" class="com.sgc.pojo.UserT" name="user2">
<bean id="userT" class="com.sgc.pojo.UserT" name="userT2,u2 u3;u4"/>
分隔这里的name的名字时候，可以用逗号分隔，也可以用空格分隔，也可以用分号分隔，或者混合
5.3 import
一般用于团队开发，可以使得多个配置文件导入合并为一个。
假设项目中有多个人开发，负责不同的类，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个，使用的时候使用总的就可以了。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<import resource="beans.xml"></import>
<import resource="beans2.xml"></import>
<import resource="beans3.xml"></import>
</beans>
