Spring初步了解到深入理解

于 2023-10-24 14:54:28 发布
阅读量302 收藏
点赞数
文章标签： 1024程序员节
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45802793/article/details/134012541
版权

文章目录

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>
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反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为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/>

12.整合MyBatis

步骤：

1.导入jar包

  • junit
  • mybatis
  • mysql数据库
  • spring相关
  • aop织入
  • mybatis-spring【new】

2.编写配置文件

3.测试

12.1回忆Mybatis

1.编写实体类

2.编写核心配置文件

3.编写接口

4.编写Mapper

5.测试

南一道街丶
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring深入理解
weixin_44800330的博客
07-03 175
本文写作思想来源于其他博客，在这里附上大神的连接：spring深入理解 1.什么是Spring？用一句话概括。 spring是一个为了解决企业应用程序开发的，一个开源框架。内部采用了IOC容器来管理Bean之间的关系以及Bean的生命周期，采用AOP的编程思想，实现了分层架构，可以与其他很多优秀的框架集成。 2.spring的架构图(拿一张度娘的图) 我们可以看到，sprin...
深入理解 Spring 事务原理
marcushbs的博客
01-03 112
Spring事务的基本原理 Spring事务的本质其实就是数据库对事务的支持，没有数据库的事务支持，spring是无法提供事务功能的。对于纯JDBC操作数据库，想要用到事务，可以按照以下步骤进行： 获取连接 Connection con = DriverManager.getConnection() 开启事务con.setAutoCommit(true/false); 执行CRUD 提交事务/回滚...
Spring Aop初步理解到深入底层
qq_42432033的博客
01-17 124
Spring Aop一.理解Aop1.什么是Aop2.Aop有什么用3.Aop应用场景4.如何使用Aop二.Aop功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 一.理解Aop 1.什么是Aop Aop（Aspect Orient
spring-transactional初步了解
java技术博客
09-01 120
spring-transactional 案例简介 本案例主要用于深入了解 Spring 的事务注解@Transactional。 @Transactional 特性 @Transactional注解只能应用到 public 修饰符上，对其他修饰符不起作用，但不报错。 @Transactional 一般加到实现类或实现类方法上，不要加到接口或接口方法上。 @Transactional仅仅对 unchecked 异常进行事务异常回滚；如果是 checked 异常则不进行异常回滚。 unchecked 异常
Spring 初步实现LDAP 域认证
12-21
在本文中，我们将探讨如何使用Spring框架来实现LDAP（轻量级目录访问协议）域认证。...虽然文中开发者表示对具体实现的理解还不够深入，但这个例子为其他开发者提供了一个起点，帮助他们在遇到类似问题时能快速上手。
spring4.3.29-3.2.18
03-04
源码编译使用.zip" 和 "spring-framework-3.2.18.RELEASE.zip" 提供了这两个版本的源代码，这对于深入理解Spring的工作原理、调试问题或进行自定义扩展非常有价值。通过阅读和分析源码，开发者可以更好地掌握Spring...
spring security初步搭建
09-26
通过阅读和理解这些源代码，你将能够深入理解Spring Security的工作原理，以及如何根据需求定制和扩展其功能。 总之，Spring Security的初步搭建是学习其核心机制的关键步骤。通过注释详尽的源码，你可以逐步掌握...
初识Spring框架-资料.rar
03-26
Spring框架是Java开发领域中...以上是对Spring框架的初步认识，深入学习和实践，可以借助“初识Spring框架-资料.rar”中的教程、文档和示例，逐步掌握Spring的各个方面，从而在实际项目中更加熟练地运用这一强大框架。
Spring AMQP hello world
11-15
通过这个简单的“Hello World”例子，你已经初步了解了Spring AMQP的基本工作流程。实际项目中，你可以根据需求创建更复杂的队列、交换机和绑定，实现更高级的功能，如发布/订阅模式、延迟消息、死信队列等。 ...
JavaScript 音乐播放器及其源代码.zip
07-22
项目：带有源代码的 JavaScript 音乐播放器 JavaScript 音乐播放器是一个使用 JavaScript、CSS 和 HTML 开发的简单项目。这个项目很有趣。在这里，用户可以通过单击不同颜色的图块来播放不同类型的曲调，并欣赏音乐的声音。此外，用户可以像钢琴一样使用它们来生成不同的曲调。   项目制作 音乐播放器项目仅包含 HTML、CSS 和 JavaScript。谈到该系统的功能，用户可以播放不同类型的音乐。您只需单击不同颜色的图块即可收听音乐。该项目包含大量 JavaScript，用于使项目正常运行。 如何运行该项目？ 要运行此项目，您不需要任何类型的本地服务器，但需要浏览器。我们建议您使用现代浏览器，如 Google Chrome 和 Mozilla Firefox。要运行此系统，首先，通过单击 index.html 文件在浏览器中打开项目。 演示： 该项目为国外大神项目，可以作为毕业设计的项目，也可以作为大作业项目，不用担心代码重复，设计重复等，如果需要对项目进行修改，需要具备一定基础知识。 注意：如果装有360等杀毒软件，可能会出现误报的情况，源码本身并无病毒，使用源码时可以关闭360，或者添加信任。
鸿蒙开发健康app案例
07-22
该项目是记录用户日常饮食情况，以及针对不同食物摄入营养不同会有对应的营养摄入情况和日常运动消耗情况，用户可以自己添加食品以及对应的热量。 主要有登陆界面，饮食统计页面，食物列表页 登陆界面首先是进入欢迎界面，然后加载首选项，用户同意授权进入首页，否则弹出用户协议，同意保存首选项，否则就跳出app 饮食统计界面，进入首页之后，用户可以选择日期和获取当前日期来加载饮食记录，饮食记录会展示热量统计，营养统计和分组展示饮食记录 食物列表页展示食物列表以及可以填写食物数量和跳转到食物详情页
1_2_1_pointcloud_based_occupancy_gride_map.launch.py
07-22
1_2_1_pointcloud_based_occupancy_gride_map.launch.py
USB教程与源码.rar
07-22
USB教程与源码.rar
巴比达内网穿透技术-内网穿透
07-22
巴比达内网穿透技术-内网穿透
基于python的网页自动化工具 既能控制浏览器，也能收发数据包
07-22
基于python的网页自动化工具。既能控制浏览器，也能收发数据包。可兼顾浏览器自动化的便利性和requests的高效率。功能强大，内置无数人性化设计和便捷功能。语法简洁而优雅，代码量少。
ppp协议实验路由器中的一种实验
最新发布
07-22
ppp协议实验路由器中的一种实验
Matplotlib styles for scientific plotting
07-22
Matplotlib styles for scientific plotting
玩机社区系统源码 2024年最美社区源码 全开源 带后端.zip
07-22
玩机社区系统源码 | 2024年最美社区源码 全开源 带后端
只对spring cloud有一个初步的了解，怎么写到简历里面
02-22
我对Spring Cloud有很深入的了解，并且能够熟练使用它来构建高可用，可扩展的微服务架构。我可以使用Spring Cloud的多种组件来构建和设计高可用的架构，并且熟练使用Spring Cloud的服务发现，配置中心，熔断器，负载...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值