1.Spring
1.1 简介
-
spring:软件行业的春天
-
2002年,首次推出Spring框架的雏形:interface21框架!!
-
spring框架以interface21框架为基础,经过不断设计,并不断丰富内涵,于2004年3月四日,发布版本
- 创始人:Rod johnson Spring Framwork创始人
-
spring设计理念:使现有的技术更加容易使用,本身是一个大杂烩,整合了现有技术的框架。
-
SSH: Struct2+Spring+Hibernate!
-
SSM: SpringMVC + Spring +Mybatis !
1.2 、优点
- Spring是一个开源的免费的框架(容器)!
- 是一个轻量级的、非入侵式的框架!
- 控制反转(IOC)
- 面向切面(AOP)
- 支持事务的处理,对框架整合的支持!
总结一句话:Spring就是一个轻量级的控制反转(IOC) 和面向切面编程(AOP)的框架!!
1.3、组成
1.4、拓展
- Spring Boot(构建一切)
- 一个快速开发的脚手架
- 一个基于SpringBoot可以快速开发单个微服务
- 约定大于配置!!!
- Spring Cloud(协调一切)
- SpringCloud是基于SpringBoot实现的
因为现在大多数公司都在使用SpirngBoot进行快速开发,学习springboot的前提,就是完全掌握spring以及springmvc!承上启下的作用
2.IOC理论推导
//DAO层
package dao;
public interface UserDao {
public void getuser();
}
package dao;
public class UserDaoimpl implements UserDao{
@Override
public void getuser() {
System.out.println("我是第一"); }
}
package dao;
public class UserTwoimpl implements UserDao{
@Override
public void getuser() {
System.out.println("我是第二");
}
}
//service层
package service;
public interface UserService {
public void getuser();
}
package service;
import dao.UserDao;
import dao.UserDaoimpl;
import dao.UserTwoimpl;
public class UserServiceimpl implements UserService{
private UserDao userDao =new UserTwoimpl();//这样的话就会非常的麻烦,你需要用哪个包修改new对象
@Override
public void getuser() {
userDao.getuser();
}
}
//text测试类
UserServiceimpl userServiceimpl= new UserServiceimpl();
userServiceimpl.getuser();
//这就是传统的java实现业务逻辑,而在新版的ioc中,完美解决这种冗余的方法
- UserDao层 接口
- UserDaoimpl 实现类
- UserService 业务接口
- UserServiceImpl 业务实现类
在我们之前的业务中,用户的需求可能会改变我们原来的代码,我们需要根据用户的需求来修改源代码!!!如果程序代码量十分大,修改一次的成本是十分高额的
- 我们是用一个set接口
-
private UserDao userDao; //利用set进行动态实现值得注入 //这种方法革命性的改变了代码的复杂性 //这就是set方法 public void setUserDao(UserDao userDao) { this.userDao = userDao; } //好处是:修改代码不需要改变代码,修改new的方式,现在只需要现货区set接口这个dao层,然后 public class Mytest { public static void main(String[] args) { //业务调取的实际是业务层,dao层不需要接触 UserServiceimpl userServiceimpl= new UserServiceimpl(); //userServiceimpl.getuser(); userServiceimpl.setUserDao(new UserTwoimpl());//只需要改变set里面的实现类即可,不需要让程序主动创建对象了 userServiceimpl.getuser(); } }
-
之前,程序是主动创建对象!!控制权在程序猿手上
-
使用了set注入后,程序不再拥有主动性,而是变成了被动接受对象
-
这种思想,从本质上改变了问题,我们程序员不用再去管理对象的创建了。系统的耦合性大大降低,可以全心进入业务的实现上,这是IOC的原型
-
这就是控制反转:在传统的java中,通常有对象内部的new来创建对象,让程序主动去创建依赖对象,而在ioc中,ioc有专门一个容器,专门用来创建这些对象,所以现在将控制权交给了ioc,即由ioc容器来控制对象的创建
-
何为正转:传统java中,有我们自己在对象中主动控制去直接获取依赖对象,也就是正转。
-
何为反转:有容器来帮忙创建及注入依赖对象;有容器来帮助我们查找以及注入依赖对象,对象只是被动地接受依赖对象,依赖对象的获取被反转了[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qesqW9ME-1642507082726)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210529180814154.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ENtIgVn8-1642507082727)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210529183925684.png)]
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="mysqlimpl" class="dao.UserDaoimpl"></bean><!---->
<bean id="userd" class="service.UserServiceimpl">
<!--
ref:引用Spring容器中创建好的对象
value:具体的值,基本数据类型
-->
<property name="userDao" ref="mysqlimpl"></property>
</bean>
</beans>
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.UserServiceimpl;
public class Mytest {
public static void main(String[] args) {
//获取ApplicationContext :拿到spring的容器
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//容器在手天下我有,需要什么,就直接get什么
UserServiceimpl userServiceimpl = (UserServiceimpl) context.getBean("userd");
userServiceimpl.getuser();
}
}
- 对象由Spring来创建,管理,装配!!!
3.IOC创建对象的方式
-
使用无参构造创建对象,默认!!
-
使用有参构造创建对象
-
下标赋值
<!--有参构造如何创建对象。 采用下标赋值 --> <bean id="user" class="com.pojo.User" > <constructor-arg index="0" value="姚海"></constructor-arg> </bean>
-
类型
<!--有参构造如何创建对象。 采用类型赋值 不推荐使用,因为有个能第二个参数也是string类型,这样不好识别 --> <bean id="user" class="com.pojo.User" > <constructor-arg type="java.lang.String" value="姚海"></constructor-arg> </bean>
-
参数名
<!--有参构造如何创建对象。 采用参数名赋值 推荐使用 --> <bean id="user" class="com.pojo.User" > <constructor-arg name="name" value="姚海"></constructor-arg> </bean>
-
-
Spring就相当于一个婚介所,需要创建的对象就将它写在beans容器配置文件中,代替了以前new的方式,但是效果一样
-
总结:在配置文件加载的时候,容器中管理的对象就已经被初始化了
4.Spring配置
4.1别名:
-
<alias name="user" alias="userNew"/>
4.2、Beam的配置
-
<!--直接在工程里面起别名 id : bean 的唯一标识符 ,也就是相当于我们学的对象名 class : bean 对象所对应的全限定名 :包名+ 类型 name : 也是别名,而且可以起多个别名 --> <bean id="user" class="com.pojo.User" name="us1 us2 us3"> </bean>
5.3、import
这个import,一般用于团队开发使用,它可以将多个配置文件,导入合并为一个
- 将多个beans.xml配置文件合并为一个总的,使用的时候只用使用总的一个
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lKO6ZniU-1642507082727)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210529195356728.png)]
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hxD3DQYH-1642507082727)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210529195555987.png)]
6、依赖注入
6.1、构造器注入
6.2、set方式注入【重点】
- 依赖注入:Set注入!!
- 依赖:bean对象的创建依赖于容器
- 注入:bean对象中的所有属性,由容器来注入
【环境搭建】
-
复杂类型
package com.yao.pojo; public class Address { private String address; public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } @Override public String toString() { return "Address{" + "address='" + address + '\'' + '}'; } }
-
真实测试对象
private String name; private Address address; private String[] books; private List<String> hobbys; private Map<String,String> card; private Set<String> games; private Properties info; private String wife;
-
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" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <bean id="student" class="com.yao.pojo.Student"> <!--第一种,普通值注入,value--> <property name="name" value="姚海" ></property> </bean> </beans>
-
测试类
import com.yao.pojo.Student; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class MyText { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); Student student = (Student) context.getBean("student"); System.out.println(student); } }
-
完善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" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <bean id="address" class="com.yao.pojo.Address"> <property name="address" value="sdasd"></property> </bean> <bean id="student" class="com.yao.pojo.Student"> <!--第一种,普通值注入,value--> <property name="name" value="姚海" ></property> <!--第二种,Bean注入,ref--> <property name="address" ref="address" ></property> <!--数组注入--> <property name="books"> <array> <value>红楼梦</value> <value>西游记</value> <value>三国演义</value> </array> </property> <!--List注入--> <property name="hobbys"> <list> <value>听歌</value> <value>敲代码</value> <value>听歌</value> </list> </property> <!--Map注入--> <property name="card"> <map> <entry key="身份证" value="411528" ></entry> <entry key="银行卡" value="411528" ></entry> </map> </property> <!--Set--> <property name="games"> <set> <value>LOL</value> <value>CBC</value> <value>BOB</value> </set> </property> <!--NULL注入--> <property name="wife"> <null/> </property> <!--propertys--> <property name="info"> <props> <prop key="driver">2019125</prop> <prop key="url">男</prop> <prop key="username">root</prop> <prop key="password">2019125</prop> </props> </property> </bean> </beans>
6.3、扩展方式注入
7、c命名和p命名空间注入
p命名:要有第三方的约束
xmlns:p="http://www.springframework.org/schema/p" 标题加上这句
<bean id="user" class="com.yao.pojo.User" p:name="请将" p:age="18">
</bean>
c命名:构造器注入也要有第三方注入
xmlns:c="http://www.springframework.org/schema/c"
<!--c命名空间注入,通过构造器注入: c:construct -->
<bean id="user2" class="com.yao.pojo.User" c:age="18" c:name="姚海"></bean>
scopes:作用域
6.4、bean的作用域
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z1jbZuBk-1642507082727)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210530234624880.png)]
- 单例模式(spring默认机制):对象只注入一次,创建多个对象它的实例还是只有一个
<bean id="user" class="com.yao.pojo.User" p:name="请将" p:age="18" scope="singleton">
Student student = (Student) context.getBean("student");
Student student1 = (Student) context.getBean("student");
//使用单例模式:student与student1对象一样
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0R89Ro43-1642507082728)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210530234702495.png)]
-
原型模式:每次从容器上get的时候,都会产生一个新对象!!!
<bean id="user2" class="com.yao.pojo.User" c:age="18" c:name="姚海" scope="prototype"></bean>
Student student = (Student) context.getBean("student"); Student student1 = (Student) context.getBean("student"); //使用原型模式:student与student1对象是两个新对象
-
其余的request、session、application、这些只能在web中使用到!!!
7.Bean的自动装配
- 自动装配是Spring满足bean依赖的一种方式
- Spring会在上下文中寻找,并自动给beam装配属性
在spirng中有三种装配方式
7.1测试
- 环境搭建:一个人有两个宠物!!!
7.2、ByName自动装配
<bean id="dog" class="com.yao.pojo.Dog"></bean>
<bean id="cat" class="com.yao.pojo.Cat"></bean>
<!--
byName:会自动在容器上下文中查找,和自己对象set方法后面的值对应的 beanid!!
-->
<bean id="people" class="com.yao.pojo.People" autowire="byName">
<property name="name" value="小毛孩啊"></property>
<!-- <property name="dog" ref="dog"></property>
<property name="cat" ref="cat"></property>-->
</bean>
7.3、ByType自动装配
<bean id="dog" class="com.yao.pojo.Dog"></bean>
<bean id="cat" class="com.yao.pojo.Cat"></bean>
<!--
bytype:会自动在容器上下文中查找,和自己对象属性类型相同的bean!!!
-->
<bean id="people" class="com.yao.pojo.People" autowire="byType">
<property name="name" value="小毛孩啊"></property>
<!-- <property name="dog" ref="dog"></property>
<property name="cat" ref="cat"></property>-->
</bean>
小结:
- byname的时候,需要保证bean的idid唯一,并且这个bean需要和自动注入的属性的set方法一致
- bytype的时候,需要保证所有的bean的class唯一,并且这个bean需要和自动注入的属性的类型一致
7.4、使用注解实现自动装配
jdk1.5支持的注解,spring2.5就开始支持的注解了!!
The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML.
要使用注解须知:
-
导入约束 context约束
-
配置注解的支持 context:annotation-config/
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <context:annotation-config/> </beans>
@Autowired
在使用该注解时,是将一个类引入到另一个类中,在引入的时候,会自动从IOC池中根据类名去获取
直接在属性上使用即可!!!也可以在set方法上使用!!
使用Autowired 我们可以不用编写Set方法了,前提是你这个自动装配的的 属性 在 ioc容器中存在,且符合byname
科普:
@Nullable 字段标记了这个注解,说明这个字段可以为null
public class People { //如果显示定义了aotowired的required属性为false ,说明这个对象可以为null,否则不允许为空 @Autowired(required = false) private Cat cat; @Autowired private Dog dog; private String name; }
一对一 一对多 多对多
sql语句中列传行 行转列
@Component:
-
将该类注入到IOC容器中,其中id默认为该类类名小写
-
将一个普通bean,将注解的类在容器中创建bean实例
-
//@Component:可以替代bean容器中的书写 <bean id="dog" class="entry.Dog"></bean>
-
//需要在bean中输入约束 <context:component-scan base-package="com.yao.pojo"/> <!--bean中扫描包-->
-
所有的注解都跟IOC容器挂钩
@Data @AllArgsConstruetor @NoArgsConstau
-
该注解写在类中可以代替所有set/get方法的构建
//在maven中引入lombok lombok
@Qualifier
-
当有多个对象时候,指定其中一个
-
<!--bean中有多个对象时候--> <bean id="dog222" class="com.yao.pojo.People"/> <bean id="dog111" class="com.yao.pojo.Dog"/> <bean id="dog333" class="com.yao.pojo.Dog"/>
-
@Autowired @Qualifier(value ="dog222")//如果有多个对象且类型相同,该注解可以指定其中一个 private Dog dog;
如果@Autowirde自动装配的环境比较复杂,自动装配无法通过一个注解[@Autowirde]完成的时候,我们可以使用@Qualifier(value = “xxx”)
去配置@Autowirde的使用,指定一个唯一的bean对象注入。
@Resource
@Resource(value = “”)不指定value值得话需要 对象和bean中的id一样才能查找到 指定value值则需要跟beanid对应
- 不属于spirng,java中的一个原注解,可以
- @Resource通过byname实现,如果找不到名字,则通过Bytype
- 是一个@Autowirde和@Qualifier的结合体
小结:两者的区别
-
都是用来自动装配的,都可以放在属性字段上
-
@Autowirde通过byType实现、、而且必须要求这个对象存在 【常用】
-
@Resource通过byname实现,如果找不到名字,则通过Bytype、、如果两个都找不到,就报错【常用】
-
执行顺序不同:
8.使用注解开发
在Spring4之后,要使用注解开发,必须要保证 aop 的包导入
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GIs2JdEC-1642507082728)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210531165618701.png)]
使用注解需要导入context约束,增加注解的支持:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!---->
<context:annotation-config/>
<!--指定要扫描的包,这个包下的注解就会生效-->
<context:component-scan base-package="com.yao.pojo"/>
-
bean
-
属性如何注入
@Value("dsad")//该注解可给属性赋值 private String name; //相当于<property name = "name" value="dsad"/> @Value("dsad")//该注解可给属性赋值 public void setName(String name){ this.name = name; }
-
衍生的注解
@Component有几个衍生的注解,在我们web的开发中,会按照mvc三层架构分层
-
dao【@Repository】
-
service【@Service】
-
controller【@Controller】
-
三个注解要用到包扫描然后注册到bean里面
-
<context:component-scan base-package="com.yao.pojo.*"/><!--代表了这个包下的几个层注册到bean里面,这是包扫描->
这四个注解功能都是一样的,都是代表将某个类注册到Spring中,装配Bean
-
-
自动装配置
- @Autowired : 自动装配通过类型 。名字 如果@Autowirde不能唯一自动装配上属性,则需要通过@Qualifier(value="xxx) - @Nullable 字段标记了这个注解,说明这个字段可以为null - @Resource :自动装配通过名字。类型
-
作用域
@Scope(“prototype”)原型模式
@Scope(“singleton”)单例模式
在类开头使用
-
小结
xml与注解:
- xml更加万能,适用于任何场合!维护简单方便
- 注解 ! 不是自己的类使用不了,维护相对复杂
最佳实践:
-
xml用来管理bean
-
注解只负责完成属性的注入
-
我们在使用的过程中,只需要注意一个问题,必须让注解生效,就需要开启注解的支持
<!--指定要扫描的包,这个包下的注解就会生效--> <context:component-scan base-package="com.kuang"/> <context:annotation-config/>
9、使用Java的方式配置Spring
我们现在要完全不适用Spring的xml的配置了,全权交给Java来做!!!
JavaConfig 是Spring的一个子项目,在Spring 4之后,它成为了一个核心功能
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-afir7i7C-1642507082728)(C:\Users\宁智波带土\AppData\Roaming\Typora\typora-user-images\image-20210531230510544.png)]
1.一个是用注解配置的上下文
2.classpath配置的上下文
实体类
package com.yao.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//这里这个注解的意思,就是说明这个类被Spirng接管了,注册到了容器中
@Component
public class User {
private String name;
public String getName() {
return name;
}
@Value("姚海")//属性的注入值
public void setName(String name) {
this.name = name;
}
public User() {
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
配置文件
package com.yao.config;
import com.yao.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
//这个也会被Spirng容器托管,因为他本身就是一个@Component,@Configuration代表这是一个配置类,就和我们之前看的beans.xml一样的
@ComponentScan("com.yao.pojo")
//扫描包
public class Yaoconfig {
//注册一个Bean , 就相当于我们之前写的一个bean标签
//这个方法的名字,就相当于bean标签中的id属性
//这个方法的返回值,就相当于
@Bean
public User user(){
return new User();//就是返回要注入到bean的对象!!
}
}
测试类
package com.yao;
import com.yao.config.Yaoconfig;
import com.yao.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class MyText {
public static void main(String[] args) {
//如果完全使用了配置类方式去做,我们就只能通过AnnotationConfig 上下文来获取容器,通过配置类的class对象加载
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Yaoconfig.class);
User getUser = (User)applicationContext.getBean("user");
System.out.println(getUser.getName());
}
}
这种纯Java的配置方式,在SpringBoot中随处可见!!!
10.动态代理
/扫描包
public class Yaoconfig {
//注册一个Bean , 就相当于我们之前写的一个bean标签
//这个方法的名字,就相当于bean标签中的id属性
//这个方法的返回值,就相当于
@Bean
public User user(){
return new User();//就是返回要注入到bean的对象!!
}
}
测试类
```java
package com.yao;
import com.yao.config.Yaoconfig;
import com.yao.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class MyText {
public static void main(String[] args) {
//如果完全使用了配置类方式去做,我们就只能通过AnnotationConfig 上下文来获取容器,通过配置类的class对象加载
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Yaoconfig.class);
User getUser = (User)applicationContext.getBean("user");
System.out.println(getUser.getName());
}
}
这种纯Java的配置方式,在SpringBoot中随处可见!!!