Spring初步了解到深入理解

文章目录

- - 1.Spring
  - - 1.1简介
    - 1.2优点
    - 1.3组成
    - 1.4拓展
  - 2.IOC理论推导
  - 3.Hello Spring
  - - 下面牵扯到的地址:
  - 4.IOC创建对象的方式
  - - 1.使用无参构造创建对象，默认
    - 2.假设我们要使用有参构造创建对象
    - - 1.下标赋值
      - 2.类型
      - 3.参数名
  - 5.Spring配置
  - - 5.1别名
    - 5.2bean的配置
    - 5.3import
  - 6.依赖注入
  - - 6.1构造器注入
    - 6.2Set方式注入\[重点]
    - 6.3拓展方式注入
    - - list这些
      - p命名
      - **其实C命名空间就对应构造器注入，p命名空间就对应Set方式注入**
      - userbeans.xml(使用)
      - User.java(包装)
      - MyTest.java(测试)
    - 6.4 bean的作用域
    - - 1.单例模式(Spring默认机制)
      - 2.原型模式
      - 3.其余的request,session,application,这个只能在web开发中使用到
  - 7.Bean的自动装配
  - - 7.1测试
    - 7.2ByName自动装配
    - 7.3ByType自动装配
    - 7.4 使用注解实现自动装配
    - - 重要：<context:annotation-config/>
      - **@AutoWired**
      - @Qualifier
      - @Resource
      - 小结：
  - 8.使用注解开发
  - - 1.bean
    - 2.属性如何注入
    - 3.衍生的注解
  - 9.使用Java的方式配置Spring
  - 10、代理模式
  - - 10.1 静态代理
    - 10.2加深理解
    - 10.3动态代理
    - Interface InvocationHandler
    - Class Proxy
    - 反射
    - - ServiceImpl
      - Test
      - ProxyInvocationHandler
  - 11.AOP
  - - 使用AOP需要导入的依赖
    - 11.3使用Spring实现扫描AOP
    - 方式一：使用API接口【主要是SpringAPI接口的实现】
    - - UserServiceImpl提供信息
      - Log日志当执行前出入
      - AfterLog日志在执行后
      - AOP负责连接
      - 最后的测试类
    - 方式二：使用自定义类【主要是切面定义】
    - - 自定义了一个Java文件
    - 方式三：使用注解开发AOP
    - - 新建一个类使用注解
      - xml导入bean
  - 12.整合MyBatis
  - - 12.1回忆Mybatis

1.Spring

1.1简介

Spring—>给软件行业带来了春天
Spring是一个轻量级的控制反转(IOC)和面向切面(AOP)的容器框架
2002，首次推出了Spring框架的雏形
Spring框架以interface21框架为基础,经过重新设计，并不断丰富内涵，与2004年发布1.0正式版
SSH：Struct2+Spring+Hibernate
SSM: SpringMVC + Spring + Mybatis
官网:https://spring.io/projects/spring-framework
下载地址：https://repo.spring.io/release/org/springframework/spring/
GitHub地址：https://github.com/spring-projects/spring-boot

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

1.2优点

Spring是一个开源的免费的框架
Spring是一个轻量级的非入侵式的框架
控制反转(IOC),面向切面编程(AOP)
支持事务的处理，对框架整合的支持

总结：Spring是一个轻量级的控制反转(IOC)和面向切面编程(AOP)的框架

1.3组成

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

1.4拓展

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

Spring Boot
- 快速开发的脚手架
- 基于SpringBoot可以快速开发单个的微服务
- 约定大于配置
Spring Cloud
- SpringCloud是基于SpringBoot实现的

弊端：发展了太久之后，违背了原来的理念，配置十分繁琐

2.IOC理论推导

1.UserDao接口
2.UserDaoImpl实现类
3.UserService业务接口
4.UserServiceImpl业务实现类

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求修改源代码！如果程序代码量非常大，修改一次的代价十分昂贵！

我们使用Set接口实现对接口的切换

   private UserDao  userDao ;
  //利用set动态实现值的注入
  public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
  }
//然后在MyTest中
   ((UserSeriviceImpl) userService).setUserDao(new UserDaoMySql());

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

3.Hello Spring

下面牵扯到的地址:

https://docs.spring.io/spring-framework/docs/5.2.0.RELEASE/spring-framework-reference/

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

4.IOC创建对象的方式

1.使用无参构造创建对象，默认

2.假设我们要使用有参构造创建对象

1.下标赋值

//User.java中定义有残构造
  public User(String name){
   this.name = name;
  }
//beans.xml中
    <bean id="user" class="com.hou.pojo.User">
        <constructor-arg index="0" value="小狂"/>
    </bean>

2.类型

<!--    第二种方式不建议使用-->    
<bean id="user" class="com.hou.pojo.User">
        <constructor-arg type="java.lang.String" value="琴酒"/>
    </bean>

3.参数名

    <bean id="user" class="com.hou.pojo.User">
        <constructor-arg name="name" value="琴酒"/>
    </bean>

总结:在配置文件加载的时候，容器中管理的对象就已经初始化了

5.Spring配置

5.1别名

<alias name="user" alias="users"/>

5.2bean的配置

    
<!--     name可以取别名而且name可以取多个别名-->
<bean id="user1" class="com.hou.pojo.User1" name="user12">
<!--     在getBean使用之前就user1这个对象就被创建好了-->
        <property name="name" value="西部开源"/>
    </bean>

5.3import

import一般用于团队开发使用，它可以将多个配置文件，导入合并为一个

6.依赖注入

6.1构造器注入

前面已经说过了

6.2Set方式注入[重点]

依赖注入：Set注入
- 依赖:bean对象的创建依赖于容器
- 注入:bean对象中所有属性由容器注入

【环境搭建】

1.复杂类型

public Address getAddress() {
    return address;
  }

  public void setAddress(Address address) {
    this.address = address;
  }
  private Address address;

2.真实测试对象

public class Student {

  private String name;
  private Address address;
  private String[] books;
  private List<String>  hobbys;
  private Map<String,String> card;
  private Set<String> games;
  private String wife;
  private Properties info;
  }

3.beans.xml

<?xml version="1.0" encoding="UTF8"?>
<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">
    <!--    这里修改最后一个https成http还是报错  不知道为什么-->
    <!--bean = 对象-->
    <!--id = 变量名-->
    <!--class = new的对象-->
    <!--property 相当于给对象中的属性设值-->

    <bean id="student" class="com.hou.pojo.Student">
<!--        第一种，普通值注入-->
        <!--        如果填写除了Name都会报错，因为没有设置name-->
        <property name="name" value="琴酒"/>

    </bean>



</beans>

4.测试类

import com.hou.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
  public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
    Student student = (Student) context.getBean("student");
    System.out.println(student.getName());
  }
}

6.3拓展方式注入

list这些

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

<bean id="address" class="com.hou.pojo.Address">
        <property name="address" value="成都"></property>
    </bean>
    <bean id="student" class="com.hou.pojo.Student">
<!--        第一种，普通值注入-->
        <!--        如果填写除了Name都会报错，因为没有设置name-->
        <property name="name" value="琴酒"/>
<!--        第二种注入bean注入-->
        <property name="address" ref="address"/>
<!--        数组中注入,ref-->
        <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="1212121233333"/>
                <entry key="银行卡" value="9536323233535"/>
                <entry key="" value=""/>
            </map>
        </property>

<!--        Set-->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>
<!--        null-->
         <property name="wife">
             <null/>
         </property>
<!--         Properties
            key = value
            key = value
            -->
        <property name="info">
            <props>
                <prop key="学号">20190525</prop>
                <prop key="性别">男</prop>
                <prop key="姓名">小明</prop>
            </props>
        </property>
    </bean>

p命名

<!--    p命名空间注入可以直接注入属性-->

    <bean id="user" class="com.hou.pojo.User" p:age="18" p:name="琴酒"/>

其实C命名空间就对应构造器注入，p命名空间就对应Set方式注入

userbeans.xml(使用)

//userbeans.xml
<?xml version="1.0" encoding="UTF8"?>
<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

<!--    现在先使用p命名-->
<!--    p命名空间注入可以直接注入属性-->
<!--    还需要弄一个无参构造-->
    <bean id="user" class="com.hou.pojo.User" p:age="18" p:name="琴酒"/>
    <bean id="user2" class="com.hou.pojo.User" c:age="20" c:name="伏特加"/>

</beans>

User.java(包装)

package com.hou.pojo;

public class User {
  private  String name;

  public User(String name, int age) {
    this.name = name;
    this.age = age;
  }

  private  int age;

  public User() {

  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public int getAge() {
    return age;
  }

  public void setAge(int age) {
    this.age = age;
  }

  @Override
  public String toString() {
    return "User{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
  }
}

MyTest.java(测试)

  @Test
  public  void  test2(){
//    我服了 我这里又没有配置userbeans.xml
    ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
//    我们如果知道是什么对象的话可以有第二个参数
    User user = context.getBean("user2",User.class);
    System.out.println(user);
  }

注意点：p命名和c命名空间不能直接使用，需要导入xml约束

<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

6.4 bean的作用域

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

1.单例模式(Spring默认机制)

<bean id="user2" class="com.hou.pojo.User" c:age="20" c:name="伏特加" scope="singleton"/>

2.原型模式

每次从容器中get，都会取得一个新的对象

<bean id="user2" class="com.hou.pojo.User" c:age="20" c:name="伏特加" scope="prototype"/>

3.其余的request,session,application,这个只能在web开发中使用到

7.Bean的自动装配

自动装配是Spring满足bean依赖的一种方式！
Spring会在上下文中自动寻找，并给Bean装配属性

在Spring中有三种装配的方式

1.xml中显示的配置
2.在java中显示的配置
3.隐式的自动装配

7.1测试

1.环境搭建

一个人有两个宠物

7.2ByName自动装配

<!--  byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid!-->  
   <bean id="person" class="com.hou.pojo.Person" autowire="byName">
        <property name="name" value="口区"></property>
    </bean>

7.3ByType自动装配

<!--
byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid!
byType:会自动在容器上下文中查找，和自己对象属性类型相同的bean,是根据class来判定的
-->
    <bean  class="com.hou.pojo.Dog"/>
    <bean  class="com.hou.pojo.Cat"/>
    <bean id="person" class="com.hou.pojo.Person" autowire="byType">
        <property name="name" value="口区"></property>
    </bean>

小姐：

byname,需要保证所有bean的id唯一,并且这个bean需要和自动注入的set方法值一致
bytype的时候，需要保证所有bean的class唯一,并且这个bean需要和自动注入的属性的类型一致

7.4 使用注解实现自动装配

jdk1.5支持的注解，Spring2.5就支持注解了

使用注解须知

1.导入约束

2.配置注解的支持

重要：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>

//Person.java
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;

<?xml version="1.0" encoding="UTF8"?>
<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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--    这里修改最后一个https成http还是报错  不知道为什么-->
    <!--bean = 对象-->
    <!--id = 变量名-->
    <!--class = new的对象-->
    <!--property 相当于给对象中的属性设值-->

    <!--
    byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid!
    byType:会自动在容器上下文中查找，和自己对象属性类型相同的bean,是根据class来判定的
    -->
<!--    开启注解支持-->
    <context:annotation-config/>

    <bean id="dog" class="com.hou.pojo.Dog"/>
    <bean id="cat" class="com.hou.pojo.Cat"/>
    <bean id="person" class="com.hou.pojo.Person"/>

</beans>

@AutoWired

可以直接在属性上使用！也可以在Set方式上使用

使用Autowired之后就可以不用编写Set方法,前提是你这个自动装配的属性在IOC（Spring）容器中存在，且符合名字ByName

@Nullable 字段标记了这个注解，说明字段可以为空

public @interface Autowired{
  boolean required() default true;
}

  //如果显示定义了Autowired的required属性为false,说明这个对象可以为Null,佛则不允许为空
    @Autowired(required = false)

@Qualifier

如果出现多个不同的bean可以用Qualifier来指定（使用Qualifier来配合Autowired）

    <bean id="dog22" class="com.hou.pojo.Dog"/>
    <bean id="dog222" class="com.hou.pojo.Dog"/>
    <bean id="cat222" class="com.hou.pojo.Cat"/>
    <bean id="cat2222" class="com.hou.pojo.Cat"/>

//Qualifier来指定值
@Autowired
@Qualifier(value = "cat222")
private Cat cat;
@Autowired
@Qualifier(value = "dog222")
private Dog dog;
private String name

@Resource

@Resource比较智能,
@Resource( name = "cat2")时候不会报错
@Resource的时候:
1.cat的名字不同不会报错
2.cat的类名不同不会报错

小结：

Resource和Autowired的区别

都是用来自动装配的,都可以放在属性字段上
@AutoWired 通过byType的方式实现
@Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现
执行顺序不同：@Autowired 通过byType实现

8.使用注解开发

1.bean

在Spring4之后,要使用注解开发,必须要保证aop包导入了
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

使用注解后需要导入context约束,增加注解的支持

<?xml version="1.0" encoding="UTF8"?>
<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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--    这里修改最后一个https成http还是报错  不知道为什么-->
    <!--bean = 对象-->
    <!--id = 变量名-->
    <!--class = new的对象-->
    <!--property 相当于给对象中的属性设值-->

    <!--    开启注解支持-->
    <context:annotation-config/>
</beans>

2.属性如何注入

package com.hou.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//等价于<bean id="user" class="com.kuang.pojo.User">
@Component
public class User {
  //相当于<property name="name" value="狂神">
  @Value("狂神")
  public String name;

  public void setName(String name) {
    this.name = name;
  }
}

3.衍生的注解

@Component 有几个衍生注解，我们在web开发中，会按照Mvc三层架构分层

dao【@Repository】
service【@Service】
controller【@Controller】

这四个注解功能都是一样的，都是代表将某个类注册Spring容器中,装配Bean!

4.自动装配

#注解说明

@Autowired:自动装配通过类型名字
@Nullable  字段标记了这个注解，说明这个字段可以为null
@Resource:先通过名字再通过类型

5.作用域

//等价于<bean id="user" class="com.kuang.pojo.User">
@Component


@Scope("prototype")
public class User {
  //相当于<property name="name" value="狂神">
  @Value("狂神")
  public String name;

  public void setName(String name) {
    this.name = name;
  }
}

6.小结

xml与注解:

xml更加万能，适用于任何场合！维护简单方便
注解，不是自己类使用不了，维护相对复杂!

xml与注解最佳实践:

xml用来管理bean
注解只负责完成属性的
我们在使用的过程中，只需要注意一个问题，必须让注解生效，就需要开启注解的支持

7.各个注解的作用

1、@controller 控制器（注入服务） ---相当于<bean id="UserController" class="com.hou.controller">
2、@service 服务（注入dao）  ---想当于<bean id="UserService" class="com.hou.service">
3、@repository dao（实现dao访问）
4、@component （把普通pojo实例化到spring容器中，相当于配置文件中的<bean id="user" class="com.hou.pojo.User"/>）
5.@Value("kuangshen2")
  //在xml中的扫描组件
   <context:component-scan base-package="com.hou"/>
    <!--    开启注解支持-->
    <context:annotation-config/>

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

9.使用Java的方式配置Spring

我们现在要完全不适用Spring的xml配置，全权交给Java来做

JavaConfig是Spring的一个子项目，在Spring 4之后，它成为了一个核心功能

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

//实体类
package com.hou.pojo;

import org.springframework.beans.factory.annotation.Value;

public class User {
  public String getName() {
    return name;
  }

  @Value("琴酒")    //属性注入值

  public void setName(String name) {
    this.name = name;
  }

  private String name;

  @Override
  public String toString() {
    return "User{" +
            "name='" + name + '\'' +
            '}';
  }
}

-------------------------------------------------------

  //配置文件
  package com.hou.config;

import com.hou.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;


//这里注解的意思就是这个类被Spring接管了,注册到了容器中

  //在一个类上只要加入了Configuration就类似于在外面套了一个beans
  @Configuration    //这个Configuration也会被Spring容器托管，注册到容器中，因为他本来就是一个@Component
  //怎么说呢，Configuration就代表一个配置类，就和我们之前遇到的beans.xml是一样的
 @ComponentScan("com.hou.pojo")
  @Import(HouConfig2.class)
  //这个和原来XML中的    <context:component-scan base-package="com.hou.pojo"/>是一样的
  public class HouConfig {
    //这一句就相当于在Bean里面写了一个bean文件了
    //这个方法的名字，就相当于bean标签中的id属性
    //这个方法的返回值，就相当于Bean标签中的class属性
    @Bean
    public User user(){
      return new User();
     //就是返回要注入bean的对象
    }
  }


}
-----------------------------------------------------
  //测试类
import com.hou.config.HouConfig;
import com.hou.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MyTest {
  public static void main(String[] args) {
//


    //注解里面加载的是一个类
    //如果按照配置类去做，就只能通过AnnotationConfig上下文来获取容器
    ApplicationContext context = new AnnotationConfigApplicationContext(HouConfig.class);

    User getUser = (User) context.getBean("user");
    System.out.println(getUser.getName());


//    System.out.println("asdasdsa");
  }
}

10、代理模式

代理模式是SpringAOP的底层

代理模式:

静态代理
动态代理

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

10.1 静态代理

1.抽象角色:一般会使用接口或抽象类解决

package com.hou.demo;

public interface Rent {
  public void  Rent();
}

2.真实角色：被代理的角色

package com.hou.demo;

public class Host implements Rent{
  public void Rent() {
    System.out.println("房东正在出租房子");
  }
}

3.代理角色：代理真实角色

package com.hou.demo;

public class Proxy implements Rent{
  private Host host;

  public Proxy() {
  }

  public Proxy(Host host) {
    this.host = host;
  }
  //这里因为代理是帮房东租房子所以应该用host.rent();
  public void Rent() {
    host.Rent();
    seeHouse();
    fare();
  }

  //看房
  public  void seeHouse(){
    System.out.println("中介带你看房");
  }
  //中介收费
  public  void fare(){
    System.out.println("收中介费");
  }
}

4.客户：访问代理对象的人

package com.hou.demo;

public class Client {
  public static void main(String[] args) {
    Host host = new Host();
    //代理
    //需要向这里传参
    //在构造哪里设置了有参数构造
    Proxy proxy = new Proxy(host);
    proxy.Rent();

  }
}

代理模式的好处:

可以使真实角色的操作更加纯粹
公共也就交给了代理角色，实现了业务的分工
公共业务发生拓展的时候，方便集中管理

缺点:一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会降低(动态代理应该就是为了解决这个问题)

10.2加深理解

10.3动态代理

动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写的
动态代理分为两类:
- 基于接口的动态代理：JDK动态代理
- 基于类的动态代理:cglib
- java字节码

Proxy(代理)

InvocationHanler:调用处理程序

Interface InvocationHandler

InvocationHandler是由代理实例的调用处理程序实现的接口。

每个代理实例都有一个关联的调用处理程序。当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。

Class Proxy

java.lang.Object
java.lang.reflect.Proxy

反射

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

可以使真实角色的操作更加纯粹
公共也就交给了代理角色，实现了业务的分工
公共业务发生拓展的时候，方便集中管理
一个动态代理类代理一个接口，一般就是一类业务
一个动态代理类可以代理多个类，只要实现一个接口既可以

ServiceImpl

//ServiceImpl
package com.hou.demo2;

public class UserServiceImpl implements UserService{

  public void add() {
    System.out.println("增加了一个用户");
  }

  public void delete() {
    System.out.println("删除了一个用户");
  }

  public void update() {
    System.out.println("修改了一个用户");
  }

  public void select() {
    System.out.println("查询了一个用户");
  }
}

Test

package com.hou.demo4;

import com.hou.demo2.UserService;
import com.hou.demo2.UserServiceImpl;

public class Client {
  public static void main(String[] args) {
    //真实角色
    UserServiceImpl userService = new UserServiceImpl();

    //代理角色,不存在
    ProxyInvocationHandler pih = new ProxyInvocationHandler();
    //代理接口
    pih.setTarget(userService);  //设置要代理的对象

    UserService proxy = (UserService) pih.getProxy();//动态生成代理类

    proxy.add();

  }
}

ProxyInvocationHandler

package com.hou.demo4;


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//等会我们会用这个类自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {

//  Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
//          new Class<?>[] { Foo.class },
//          handler);

  //被代理的接口

  private  Object target;

  public void setTarget(Object target) {
    this.target = target;
  }

  //得到生成代理对象
  public Object getProxy(){
    //一个类加载器，一个接口，一个InvacationHanler
     return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
  }

  //处理代理实例并返回结果
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    log(method.getName());
    //动态代理的本质，就是发射机制的实现
    Object result =method.invoke(target,args);

    return  result;

  }
  public  void log(String msg){
    System.out.println("执行"+msg+"方法");
  }

}

11.AOP

11.1 什么是AOP

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

使用AOP需要导入的依赖

dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.9.6</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>
        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
</dependency>

11.3使用Spring实现扫描AOP

方式一：使用API接口【主要是SpringAPI接口的实现】

UserServiceImpl提供信息

package com.hou.service;

public class UserServiceImpl implements UserService{

  public void add() {
    System.out.println("增加了一个用户");
  }

  public void delete() {
    System.out.println("删除了一个用户");
  }

  public void update() {
    System.out.println("更新了一个用户");
  }

  public void select() {
    System.out.println("选择了一个用户");
  }
}

Log日志当执行前出入

package com.hou.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {

  //methods:要执行的目标对象的方法
  //args:参数
  //target:目标对象
  public void before(Method method, Object[] args, Object target) throws Throwable {
    System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
  }
}

AfterLog日志在执行后

package com.hou.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog  implements AfterReturningAdvice {

  //returnValue 返回值
  public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
    System.out.println("执行了"+method.getName()+"方法,返回结果为"+returnValue);
  }
}

AOP负责连接

<?xml version="1.0" encoding="UTF8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--bean = 对象-->
    <!--id = 变量名-->
    <!--class = new的对象-->
    <!--property 相当于给对象中的属性设值-->
<!--    出现找不到这个xml需要点右上角的设置让这个xml重新加载-->

    <!--    注册bean-->
    <bean id="userService" class="com.hou.service.UserServiceImpl"/>
    <bean id="log" class="com.hou.log.Log"/>
    <bean id="afterlog" class="com.hou.log.AfterLog"/>
    <!--    使用Spring原生API接口-->
    <!--    配置aop:需要导入aop的约束-->
    <aop:config>
        <!--        切入点: expression:表达式  execution(要执行的位置)  修饰词 返回值 类名 方法名 参数-->

        <aop:pointcut id="pointcut" expression="execution(* com.hou.service.UserServiceImpl.*(..))"/>
        <!--        执行环绕增加-->
        <!--        把log这个类切入到这个方法上面-->
        <!--        因为log和afterlog里面使用的是利用反射的动态管理，所以可以用动态管理来管理接口-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterlog" pointcut-ref="pointcut"/>

    </aop:config>

</beans>

最后的测试类

import com.hou.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
  public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    //动态代理代理的是接口
    UserService userService = (UserService) context.getBean("userService");
    userService.add();
  }
}

方式二：使用自定义类【主要是切面定义】

自定义了一个Java文件

package com.hou.diy;

public class DiyPointCut {
  public void before(){
    System.out.println("=======方法执行前=========");
  }
  public void after(){
    System.out.println("=======方法执行后=========");
  }
}

在xml中做了一些修改

    <aop:config>
        <aop:aspect ref="diy">
<!--            切入点-->
<!--            我认为pointcut应该是被载入，pointcut-ref应该是载入-->
         <aop:pointcut id="point" expression="execution(* com.hou.service.UserServiceImpl.*(..))"/>
<!--            通知--><aop:before method="before" pointcut-ref="point"/>
                       <aop:after method="after" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>

方式三：使用注解开发AOP

新建一个类使用注解

package com.hou.diy;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect  //标注这个类是一个切面
public class AnnotationPointCut {
  @Before("execution(* com.hou.service.UserServiceImpl.*(..))")
  public void before(){
    System.out.println("=======方法执行前=========");
  }
  @After("execution(* com.hou.service.UserServiceImpl.*(..))")
  public void after(){
    System.out.println("=======方法执行后=========");
  }
  @Around("execution(* com.hou.service.UserServiceImpl.*(..))")
  public void around(ProceedingJoinPoint jp) throws Throwable {
    System.out.println("环绕前");
    //执行方法
    Object proceed =jp.proceed();
    System.out.println("环绕后");
//    Signature signature = jp.getSignature();  //获得签名
//    System.out.println("signature:"+signature);

//    System.out.println(proceed);
  }
}

xml导入bean

<!--    方式三-->
    <bean id="annotationPointCut" class="com.hou.diy.AnnotationPointCut"/>
<!--    开启注解支持 JDK(默认 proxy-target-class="false") cglib(proxy-target-class="true")-->
     <aop:aspectj-autoproxy/>