1.Spring
1.1 简介
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
1.2 优点
- Spring是一个开源的免费的框架(容器)
- Spring是一个轻量级的,非入侵式的框架
- 控制反转(loc),和面向切面编程(aop)
- 支持事务的处理,对框架整合的支持!
总结: Spring就是一个轻量级的控制反转(loc)和面向切面编程(aop)的框架
1.3 组成
1.4 拓展
弊端: 发展了太久了,违背了原有的理念,配置十分繁琐,人称"配置地狱"
2. IOC理论推导
这种思想,从本质上解决了问题,我们程序开发者不用再去管理对象的创建了.系统的耦合性大大降低,可以更加专注的投入到业务的开发中.
3. Hello Spring
4. IOC创建对象的方式
1.使用午餐构造创建对象.默认!
总结: 在配置文件加载的时候,容器中管理的对象就已经初始化了!
5. Spring配置
5.1 别名
<alias name="user0" alias="user0Alias"/>5.2 Bean的配置
<!--
id: bean 的唯一标识,也就是相当于我们new的对象变量名
class: bean 对象所对应的全限定名: 包名+类型
name: 也是别名,而且name可以同时取多个别名
-->
<bean id="user4" class="com.test.pojo.User" name="u1 u2,u3;u4">
<property name="name" value="bean配置测试"/>
</bean>5.3 import
一般用于团队开发使用,可以将多个配置文件,导入合并为一个
假设,现在项目中有多个人开发,这三个人负责不同类的开发,不同的类需要注册在不同的bean中,我们可以利用import将所有人的beans.xml合并为一个总的,使用的时候使用总的配置即可!
6. 依赖注入
6.1 构造器注入
6.2 set方式注入[注入]
- 依赖注入: set注入
- 依赖: bean对象的创建依赖于容器
- 注入: bean对象中属性,由容器来注入
[环境搭建]
1. 复杂类型
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}2. 真实测试对象
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbies;
private Map<String,String> card;
private Set<String> games;
private String wife;
private Properties info;
```3. 测试类
public class Test {
public static void main(String[] args){
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student)context.getBean("student");
System.out.println(student.toString());
/*
*
Student{
name='蒙天放'
, address=nanjing
, books=[红楼梦, 西游记, 水浒传, 三国演义]
, hobbies=[听歌, 打游戏]
, card={身份证=111111111, 银行卡=222222222}
, games=[王者荣耀, lol手游]
, wife='null'
, info={学号=202201, 性别=男, 姓名=蒙天放}
}
*
*/
}
}4. 配置文件
<?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">
<bean id="address" class="com.test.pojo.Address">
<property name="address" value="nanjing"/>
</bean>
<bean id="student" class="com.test.pojo.Student">
<!--第一种,普通值注入,value-->
<property name="name" value="蒙天放"/>
<!--第二种,引用注入-->
<property name="address" ref="address"/>
<!--第三种,数组注入-->
<property name="books">
<array>
<value>红楼梦</value>
<value>西游记</value>
<value>水浒传</value>
<value>三国演义</value>
</array>
</property>
<!--list-->
<property name="hobbies">
<list>
<value>听歌</value>
<value>打游戏</value>
</list>
</property>
<!--map-->
<property name="card">
<map>
<entry key="身份证" value="111111111"/>
<entry key="银行卡" value="222222222"/>
</map>
</property>
<!--set-->
<property name="games">
<set>
<value>王者荣耀</value>
<value>lol手游</value>
</set>
</property>
<!--null-->
<property name="wife">
<null/>
</property>
<!--Properties-->
<property name="info">
<props>
<prop key="学号">202201</prop>
<prop key="性别">男</prop>
<prop key="姓名">蒙天放</prop>
</props>
</property>
</bean>
</beans>
6.3 拓展方式注入
我们可以使用 p 命名空间注入和 c 命名空间进行构造器注入
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
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">
<bean id="p_user" class="com.test.pojo.PUser" p:name="张三" p:age="12"/>
</beans><?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:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="c_user" class="com.test.pojo.CUser">
<constructor-arg name="name" value="赵麟儿"/>
<constructor-arg name="age" value="18"/>
</bean>
<bean id="c_user1" class="com.test.pojo.CUser" c:name="李逍遥" c:age="22"/>
</beans>6.4 bean作用域
1. 单例模式 (Spring 默认机制)
2, 原型模式 : 每次从容器中get的时候,都会产生一个新的对象
3. 其余的 request,session,application,这些个只能在web开发中使用到!
7. bean的自动装配
- 自动装配是Spring满足bean依赖的一种方式
- Spring会在上下文中自动寻找,并自动给bean装配属性
在Spring中由三种装配的方式
1. xml中显式的配置
2. java代码中显式配置
3. 隐式的自动装配bean[重要]
7.1 ByName 自动装配
<!--
byName: 会自动在容器上下文中查找,和自己对象set方法后面的值对应的beanid!
-->
<bean id="people1" class="com.test.pojo.People" autowire="byName">
<property name="name" value="蒙天放"/>
</bean>7.2 ByType自动装配
<!--
buType: 会自动在容器上下文中查找,和自己对象类型set方法后面的值对应的beanid!
-->
<bean id="people2" class="com.test.pojo.People" autowire="byType">
<property name="name" value="蒙天放"/>
</bean>小结:
- byname: 保证所有的bean的id唯一性,并且这个bean需要和自动注入的属性的set方法的值保持一致
- bytype: 保证所有的bean的class唯一性,并且这个bean需要和自动注入的属性的类型保持一致
7.4 使用注解实现自动装配
<?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 http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tool http://www.springframework.org/schema/tool/spring-tool.xsd">
<context:annotation-config/>
</beans>@Autowired
直接在属性上使用即可!也可以在set方式上使用!
使用Autowired 我们可以不用编写set方法了,前提是这个自动装配的属性已经在 IOC 容器中存在,且符合名字 byname!
拓展:
如果 @Autowired 自动装配的环境比较复杂,自动装配无法通过一个注解[@Autowired] 完成的时候,可以使用 @Qualifier(value="xxx")去配置@Autowired的使用,指定一个唯一的bean对象注入!
@Autowired
@Qualifier(value = "dog1")
private Dog dog;
private String name;
public Cat getCat() {
return cat;
}@Resource
小结:
@Resource 和 @Autowired的区别:
- 都是用来自动装配的,都可以用在属性字段上
- @Autowired 通过byname的方式实现的
- @Resource 默认通过byname的方式实现,如果找不到名字,则通过bytype实现,如果两个都找不到的情况下,就报错![常用]
- 执行顺序不同
8. 使用注解开发
在Spring4之后,要使用注解开发,必须要保证 aop 的包导入了
使用注解需要导入 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:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- bean definitions here -->
<!--开启注解的支持-->
<context:annotation-config/>
</beans>
1. bean
2. 属性如何注入
@Component(value = "user11")
@Data
public class User {
//相当于<property name="name" value="蒙天放"/>
@Value("蒙天放")
public String name;
@Value("蒙毅")
public void setName(String name){
this.name=name;
}
}3. 衍生的注解
@Componet 有几个衍生注解,我们在web开发中,会按照mvc三层架构分层!
dao @Repository
service @Service
controller @Controller
这四个注解功能都是一样的,都是代表将某个类注册到Spring容器中,装配bean
4. 自动装配配置
@Autowired: 自动装配通过name @Resource: 自动装配,先通过name,再通过type @Component: 组件,放在类上,代表该类被Spring 管理了,就是bean!
5. 作用域
@Component(value = "user11")
@Scope("prototype")
@Data
public class User {
//相当于<property name="name" value="蒙天放"/>
@Value("蒙天放")
public String name;
@Value("蒙毅")
public void setName(String name){
this.name=name;
}
}6. 小结
xml与注解:
xml更加万能,使用与任何场合!维护简单方便
注解不是自己类 使用不了,维护相对复杂!
xml与注解最佳实践:
xml用来管理bean
注解只负责属性装配(DI)
我们在使用的过程中,只要主要一个问题: 必须让注解生效,就需要开启注解的支持
9. 使用java的方式配置Spring
我们现在要完全不使用Spring的xml配置了,全权交给java来做!
javaConfig 是 Spring 的子项目,在Spring4 之后,成为了一个核心功能!
实体类
//这个注解的意思,说明这个类被Spring接管了,注册到容器中了
@Component
public class User {
@Value("蒙天放")//属性注入值
public String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}配置类
//这个也会被Spring容器托管,他本来也是一个@Component
// @Configuration代表这是一个配置类,就和我们之前看的beans.xml
@Configuration
@ComponentScan("com.test")
@Import(MyConfig2.class)
public class MyConfig {
//注册了一个bean,就相当于我们之前写的一个bean标签
//这个方法的名字相当于bean标签的id属性
//这个方法的返回值相当于bean标签的class属性
@Bean
public User getUser(){
return new User();
}
},测试类
public static void main(String[] args){
//如果完全通过配置类的方式取处理,我们只能通过AnnotationConfigApplicationContext 上下文来获取容器,通过配置类的class对象加载
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
User user = (User)context.getBean("getUser");
System.out.println(user.getName());
}
10. 代理模式
为什么要学习代理模式?因为这就是SpringAOP 的底层!
代理模式的分类:
- 静态代理
- 动态代理
10.1 静态代理
角色分析:
- 抽象角色: 一般会使用接口或者抽象类来解决
- 真实角色: 被代理的对象
- 代理角色: 代理真实角色,代理真实角色后,我们一般会做一些额外的动作!
- 客户: 访问代理对象的人!
代码步骤:
1. 接口
//抽象角色:房子出租
public interface Rent {
public void rent();
}2. 真实角色
//真实角色:房东
public class Master implements Rent {
public void rent() {
System.out.println("房东将房子租出去了");
}
}3. 代理角色
//代理角色:充当房东,帮房东解决租房的问题
public class Proxy implements Rent{
private Master master;
public Proxy(Master master){
this.master=master;
}
public void rent() {
seeHouse();
master.rent();
signHouse();
}
public void seeHouse(){
System.out.println("中介开始带访客去看房子....");
}
public void signHouse(){
System.out.println("中介跟访客签租赁合同...");
}
}4. 客户端(访客角色)
public class Client {
public static void main(String[] args){
Master master = new Master();//房东要找访客租房子了
Proxy proxy = new Proxy(master);//代理,中介帮房东租房子,但是,代理角色一般会有一些附属操作
proxy.rent();//访客不用直接找房东,中介可以完成租房的动作
}
}静态代理模式的优缺点:
- 可以使真实角色的操作更加纯粹!不用去关注一些公共的业务
- 公共业务也就交给了代理角色!实现了业务的分工
- 公共业务发生扩展的时候,方便集中管理
- 缺点: 一个真实角色就会产生一个代理对象;代码量会翻倍,开发效率会变低
10.2 加深理解代理模式
聊聊AOP
public interface IUserService {
public void add();
public void delete();
public void update();
public void query();
}public class UserServiceImpl implements IUserService {
public void add() {
System.out.println("新增一个用户");
}
public void delete() {
System.out.println("删除一个用户");
}
public void update() {
System.out.println("更新一个用户");
}
public void query() {
System.out.println("查询一个用户");
}
}
public class UserServiceProxy implements IUserService {
private UserServiceImpl userService;
public void setUserService(UserServiceImpl userService){
this.userService=userService;
}
public void add() {
logger("add");
userService.add();
}
public void delete() {
logger("delete");
userService.delete();
}
public void update() {
logger("update");
userService.update();
}
public void query() {
logger("query");
userService.query();
}
public void logger(String methodName){
System.out.println("正在执行"+methodName+"方法!");
}
}public class Client {
public static void main(String[] args){
UserServiceImpl userService = new UserServiceImpl();
UserServiceProxy userServiceProxy = new UserServiceProxy();
userServiceProxy.setUserService(userService);
userServiceProxy.add();
userServiceProxy.delete();
userServiceProxy.update();
userServiceProxy.query();
}
}
10.3 动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的,不是我们直接写好的
- 动态代理分为两类: 基于接口的动态代理,基于类的动态代理
- 基于接口----JDK 动态代理
- 基于类-------CGLIB
- java字节码--javasist
需要了解两个类: Proxy 代理 InvocationHandler 调用处理程序
动态代理的优缺点:
- 可以使真实角色的操作更加纯粹!不用去关注一些公共的业务
- 公共业务也就交给了代理角色!实现了业务的分工
- 公共业务发生扩展的时候,方便集中管理
- 一个动态代理类代理的是一个接口,一般就是对应的一组业务
- 一个动态代理类可以代理多个类,只要是实现同一个接口
11. AOP
11.1什么是AOP
11.2 AOP 在Spring中的作用
11.3 使用Spring实现AOP
方式一: 使用 Spring 的API 接口
方式二: 自定义实现AOP
方式三: 使用注解实现
//方式三: 使用注解方式实现AOP
@Aspect //标注这个类是个切面
public class AnnotationPointCut {
@Before("execution(* com.test.service.UserServiceImpl.*(..))")
public void before(){
System.out.println("==========AnnotationPointCut::方法执行前==============");
}
@After("execution(* com.test.service.UserServiceImpl.*(..))")
public void after(){
System.out.println("==========AnnotationPointCut::方法执行后==============");
}
@Around("execution(* com.test.service.UserServiceImpl.*(..))")
public void around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("环绕前");
Object proceed = joinPoint.proceed();
System.out.println("环绕后");
}
}
12. 整合Mybatis
13. 声明式事务
扫一扫
1361
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
