Spring 的IOC和AOP以及动态代理

java1234

共 15605字,需浏览 32分钟

 ·

2021-04-25 10:08

点击上方蓝色字体,选择“标星公众号”

优质文章,第一时间送达

76套java从入门到精通实战课程分享

依赖

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 秒


感谢点赞支持下哈 

浏览 40
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报