Spring 的IOC和AOP以及动态代理
共 15605字,需浏览 32分钟
·
2021-04-25 10:08
点击上方蓝色字体,选择“标星公众号”
优质文章,第一时间送达
依赖
class a中使用class b的属性或者方法, 叫做classa依赖classb
Spring
1. IOC(控制反转)
IoC (Inversion of Control) : 控制反转, 是一个理论,概念,思想。
描述的:把对象的创建,赋值,管理工作都交给代码之外的容器实现。
控制: 创建对象,对象的属性赋值,对象之间的关系管理。
反转: 把容器代替开发人员管理对象。创建对象,给属性赋值。
正转:由开发人员在代码中,使用new 构造方法创建对象, 开发人员主动管理对象。
public static void main(String args[]){
Student student = new Student(); // 在代码中, 创建对象。--正转。
}
容器:是一个服务器软件, 一个框架(spring)
为什么要使用 ioc :
目的就是减少对代码的改动, 也能实现不同的功能。 实现解耦合
java中创建对象有哪些方式:
1. 构造方法 , new Student()
2. 反射
3. 序列化
4. 克隆
5. ioc :容器创建对象
6. 动态代理
ioc的体现:
servlet 1: 创建类继承HttpServelt
2: 在web.xml 注册servlet , 使用
<servlet-name> myservlet </servlet-name>
<servelt-class>com.bjpwernode.controller.MyServlet1</servlet-class>
3. 没有创建 Servlet对象, 没有 MyServlet myservlet = new MyServlet()
4. Servlet 是Tomcat服务器它能你创建的。 Tomcat也称为容器
Tomcat作为容器:里面存放的有Servlet对象, Listener , Filter对象
junit : 单元测试, 一个工具类库,做测试方法使用的。
使用单元测试
1.需要加入junit依赖。
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
2.创建测试作用的类:叫做测试类
src/test/java目录中创建类
3.创建测试方法
1)public 方法
2)没有返回值 void
3)方法名称自定义,建议名称是test + 你要测试方法名称
4)方法没有参数
5)方法的上面加入 @Test ,这样的方法是可以单独执行的。 不用使用main方法
IOC如何创建对象
1、声明一个bean,就是告诉spring要创建某个类的对象
id:对象的自定义名称,spring就是通过这个ID找到对象
class:类的全路径名称
Spring b把创建的对象放在map集合,
SpringMap.put(id , 对象)
xml文件 这就创建对象了
<bean id = "要创建对象的类名 别名 也可以是一样的 如:SomeServiceImpl的别名someService" class = "SomeServiceImpl的全路径名称" />
一个测试类
@Test
public voidtest(){
// 使用spring容器创建对象
1、指定spring配置文件的名称
String config = "bean.xml";
2、创建spring容器对象 ApplicationContext
ApplicationContext ac = new ClassPathXmlApplicationContext(config);
3、从容器中取对象 getbean(配置文件中bean的id)
SomeService s = (SomeService)ac.getbean("someService");
4、使用spring创建对象
s.dosome(); // dosome 是SomeService类中的方法
}
如同 SomeServiceImpl s = new SomeServiceImpl();
s.dosome();
IoC的技术实现
DI 是ioc的技术实现,
DI(Dependency Injection) :依赖注入, 只需要在程序中提供要使用的对象名称就可以, 至于对象如何在容器中创建,
赋值,查找都由容器内部实现。
spring是使用的di实现了ioc的功能, spring底层创建对象,使用的是反射机制。
spring是一个容器,管理对象,给属性赋值, 底层是反射创建对象。
set方法注入
类:
public class Student(){
private String name;
private int age;
private School school; //引用数据类型
无参构造函数
有参的构造函数
private void setName(String name){
this.name = name;
}
private void setAge(int age){
this.age= age;
}
private void setschool(School school){
this.school= school;
}
}
public class School (){
private String name;
无参构造函数
有参的构造函数
private void setName(String name){
this.name = name;
}
}
Spring 调用类中的set方法,给参数注入值
语法:
简单类型的set注入
> 1、语法
> > <bean id = "要创建对象的类名 如:someService" class = "SomeService的全路径名称" >
<property name = "参数名" value="值"/>
</bean>
xml文件
<bean id = "student" class = "Student的全路径名称" >
<property name = "name" value="老师"/>
<property name = "age" value="20"/>
</bean>
引用数据类型的set注入
2、语法
<bean id = "要创建对象的类名 如:someService" class = "SomeService的全路径名称" >
<property name = "参数名" ref=" 要引用的对象的bean的id"/>
</bean>
<bean id = "student" class = "Student的全路径名称" >
<property name = "name" value="老师"/>
<property name = "age" value="20"/>
<property name = "school" ref="school"/>
</bean>
<bean id = "school" class = "School的全路径名称" >
<property name = "name" value="清华"/>
</bean>
构造方法的注入
spring调用有参构造方法。在创建对象的时候注入值
语法
<bean id = "要创建对象的类名 如:someService" class = "SomeService的全路径名称" >
<donstructor-arg name = "参数名" value = "值"/> name :构造方法的形参名
或者
<donstructor-arg index= "0" value = "值"/> index 构造方法的形参名的位置 0 1 2
或者
value 构造方法的形参是简单类型的
ref:构造方法形参是引用类型
</bean>
<bean id = "student" class = "Student的全路径名称" >
<donstructor-arg name = "name" value = "张三"/>
<donstructor-arg name = "age" value = "20"/> name :构造方法的形参名
或者
<donstructor-arg index= "0" value = "张三"/> index 构造方法的形参名的位置 0 1 2
<donstructor-arg index= "1" value = "20"/>
<donstructor-arg index= "3" ref= "school"/>
ref:构造方法形参是引用类型s
</bean>
<bean id = "school" class = "School的全路径名称" >
<property name = "name" value="清华"/>
</bean>
引用数据类型的自动注入
byName
1、byName(按名称注入):Java类中引用数据类型的属性名和spring容器中(配置文件)引用类性的bean id 名一样
<bean id = "myStudent" class = "Student的全路径名称" autowire = "byName">
基本数据类型的赋值
</bean>
<bean id = "myStudent" class = "Student的全路径名称" autowire = "byName">
<donstructor-arg name = "name" value = "张三"/>
<donstructor-arg name = "age" value = "20"/> name :构造方法的形参名
// <donstructor-arg index= "3" ref= "school"/>
ref:构造方法形参是引用类型
</bean>
<bean id = "school" class = "School的全路径名称" >
<property name = "name" value="清华"/>
</bean>
byType
byType:按照类型注入
Java类中引用类型的数据类型和spring容器中(配置文件)bean 的class 属性是同源关系的 如在一个包下
同源 就是一类的意思
1、Java类中引用类型 的数据类型和bean的class的值一样
2、Java类引用类型的数据类型和bean的class的值是父字关系
3、Java类引用类型的数据类型和bean的class的值是接口和实现类的关系
语法
<bean id = "myStudent" class = "Student的全路径名称" autowire = "byType">
基本数据类型的赋值
</bean>
<bean id = "myStudent" class = "Student的全路径名称" autowire = "byType">
<donstructor-arg name = "name" value = "张三"/>
<donstructor-arg name = "age" value = "20"/> name :构造方法的形参名
// <donstructor-arg index= "3" ref= "school"/>
ref:构造方法形参是引用类型
</bean>
<bean id = "school" class = "School的全路径名称" >
<property name = "name" value="清华"/>
</bean>
管理对各配置文件
多个配置文件: 一个模块一个文件
如 学生一个
班级一个
学习一个
语法
再创建一个主配置文件
<beans>
<import resource = ClassPath:其他配置文件的路径
</beans>
<beans>
<import resource = ClassPath:student.xml的路径
<import resource = ClassPath:student.xml的路径
</beans>
使用注解注入
通过注解完成对象的创建,代替xml
1、加入spring-context依赖
2、在类中创建注解
3、创建spring的配置文件
扫描器:指定注解在项目中的位置
4、使用注解创建对象,创建容器ApplicationContext
@Component(对象的名称也就是bean的id)
此注解创建对象 等同 bean的功能 等同于
位置:类的上面
@Component() 默认名称 类名的首字母小写 student
配置文件
配置扫描器:component - scan
base-package:注解在项目的包名
工作方法 :spring扫码指定的包 找到注解 创建对象 赋值
三种方法
1、 <context:component-scan_base-package="包名1">
<context:component-scan_base-package="包名2">
2、<context:component-scan_base-package="包名1;包名2">
3、指定父包
<context:component-scan_base-package="父包名">
@Component("student")
public class Student(){
private String name;
private int age;
private School school; //引用数据类型
无参构造函数
有参的构造函数
private void setName(String name){
this.name = name;
}
private void setAge(int age){
this.age= age;
}
private void setschool(School school){
this.school= school;
}
}
其他创建对象的注解
这三个给项目分层
@Repository() 用在持久层,dao的实现类上面 表示创建对象dao能访问数据库
@Service()业务层在service的实现类上,创建service对象,做业务处理,有事务等功能
@Controller() 控制层:创建控制器对象,接收用户处理的参数,显示请求的结果
注解注入赋值
@Value(“张飞”) :简单数据类型赋值
用在String 类型上,基本数据类型不OK 可以使用包装类
无需set方法
位置 参数上
@Value("李双")
private String name;
@Value("20")
private int age;
//引用数据类型
引用数据类型注解注入@Autowired
:自动注入原理 支持byName 、byType; 默认byType
位置:在属性的上面
属性:required = true 赋值失败程序报错
required = false 赋值失败正常执行、引用数据为null
@Autowired
private int age;
使用byName
在属性上加@Autowired
@Qualifier(value = “bean的id”)表示指定名称的bean完成赋值
@Autowired
@Qualifier("school")
private School school;
引用数据类型注解赋值@Resource
默认byName 失败用byType
位置参数上面
@Resource
private School school
--------------------AOP切面--------------------
动态代理
1、实现方法:jdk动态代理,使用jdk中的Proxy,Method,InvocaitonHanderl创建代理对象。
jdk动态代理要求目标类必须实现接口
2.动态代理的作用:
1)在目标类源代码不改变的情况下,增加功能。
2)减少代码的重复
3)解耦合。
步骤:
1、 定义一个接口
2、定义一个类ServiceTools 类中有共有的方法 (时间、事务)doLog();doTrans();
2、定义一个接口的实现类,继承接口 重新方法 doSome();
3、写代理类:
继承IncationHandler实现代理
public Class MyIncationHandler implement IncationHandler(){
private Object target;// 实现类
public MyIncationHandler(Object target){
this target = target;
}
public Object invoke(Object proxy,Method method, Object[] args)throws Throwable{
// 通过代理对象执行方法 会调用这个invoke()
Object res = null;
ServiceTools.doLog();
// 执行目标类的方法,通过Method类实现
res = method.invoke(target,args);//执行实现类的方法
ServiceTools.doTrans();
// 目标方法的执行结果
return res;
}
}
使用jdk实现代理
public class MyApp(){
public static void main(String[] args){
SomeService target = new 实现类;
// 创建InvocationHandler
InvocationHandler handler = new MyIncationHandler(target);
// 使用proxy创建代理
SomeService proxy = (SomeService)Proxy.newProxyInsstance{
target.getClass().getClassLoader(),
target.getClass().getInterFaces(),Handler);
// 调用handler中的invoke();
proxy.dosome();
}
}
}
aspectj实现AOP
步骤
1、新建maven项目
2、加入依赖
aspectj依赖
juint单元测试
3、创建目标类:接口和实现类
4、创建切面类:普通类
(1)在类上加入@Aspect
(2) 在类中的定义方法,方法就是切面执行的代码(事务、日志、时间等)
在方法上加入aspectj的通知注解。如@before
有需要则指定切入表达式
5、创建spring配置文件,声明对象,把对象交给IOC管理
(1)声明目标对象
(2)声明切面类对象
(3)声明aspectj框架中自动代理生成器标签
6创建测试类
接口`
public interface SomeService{
void doSome(String name,Integer age);
}
实现类
public class SomeServiceImpl implements SomeService {
@Override
public void doSome(String name,Integer age){
Sysotem.out.println("执行----------")
}
}
切面类
@Aspect
public class MyAspect{
方法要求
1、public
2、void
3、方法名自定义
4、方法可以有参数也可以无参数
5、@Before前置注解
1、属性 Value 切入表达式,表示切面的执行位置
2、位置 :在方法的上面
@Before(value = "execution(public void 包下的实现类.doSome(String,Integer)")
public void myBefore(){
//切面的代码
Sysotem.out.println("时间----------")
}
}
配置文件
// 声明目标类(实现类)对象
<bean id = "someService" class = "路径名" />
// 声明切面类对象
<bean id = "myAspect" class = "全路径名" />
//声明aspectj框架中自动代理生成器标签
<aop:aspectj-autoproxy>
后置通知@AfterReturn()
要求
1、public
2、void
3、方法有参数 Object 方法名自定义
4、属性 1、value:切入点表达式
2、returning 自定义的变量,便是目标方法有返回值的
自定义的变量名必须和通知方法的形参一样
位置: 方法上面
切面类 中的方法
@@AfterReturn(value = "execution(public void 包下的实现类.doSome(String,Integer)",returning = "res")
public void myAfterReturn(Object res){ res 和,returning = "res一样
//切面的代码
Sysotem.out.println("时间----------")
环绕通知@Around
属性:value:切入表达式
位置:方法上方
特点
功能最强的通知
在目标方法前后都能加入切面类的代码
控制目标方法是否调用执行
修改原目标方法的执行结果,影响最后的调用结果
@Around(value = "execution(public void 包下的实现类.doSome(String,Integer)")
public Object myAround(ProceedingJoinPoint pjp) throws Throwable{
// 实现环体通知
Object result = null;
Sysotem.out.println("方法前")
// 目标方法调用
result = pjp.proceed();
Sysotem.out.println("方法后")
// 返回目标方法的执行结果
return result;
}
————————————————
版权声明:本文为CSDN博主「ジ你是我永远のbugグ」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:
https://blog.csdn.net/qq_47848696/article/details/115838386
粉丝福利:Java从入门到入土学习路线图
👇👇👇
👆长按上方微信二维码 2 秒
感谢点赞支持下哈