SSM框架系列学习总结2之Spring AOP

最新推荐文章于 2024-04-09 22:41:56 发布
最新推荐文章于 2024-04-09 22:41:56 发布
阅读量847 收藏 1
点赞数 2
分类专栏： SSM SSM框架系列学习总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/menglanyingfei/article/details/79117564
版权

先整理AOP之前, 我先把之前DI的内容整理完!

DI

Spring的依赖注入第二种方式:

通过构造方法注入属性
首先提供一个实体类, 不过这个类没有属性的get和set方法, 只有一个有参的构造方法和toString方法.

public class Boy {
    private String id;
    private String name;
    private Integer age;
    private Double salary;

    public Boy(String id, String name, Integer age, Double salary) {
        System.out.println("IOC容器创建对象");
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

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

Spring配置

    <!--
        通过constructor实现依赖注入
        constructor-arg: 通过构造方法传过去的值
        type: 用来限制传递的参数的类型
    -->
    <bean id="boyId" class="com.wtu.spring.di.constructor.Boy">
        <!--
        <constructor-arg type="java.lang.String">
            <value>001</value>
        </constructor-arg>
        <constructor-arg type="java.lang.String">
            <value>小阳</value>
        </constructor-arg>
        <constructor-arg type="java.lang.Integer">
            <value>16</value>
        </constructor-arg>
        <constructor-arg type="java.lang.Double">
            <value>1000</value>
        </constructor-arg>
        -->

        <!-- index: 参数在构造方法中的位置, 第一个参数从0开始 -->
        <constructor-arg index="0">
            <value>001</value>
        </constructor-arg>
        <constructor-arg index="1">
            <value>小阳</value>
        </constructor-arg>
        <constructor-arg index="2">
            <value>16</value>
        </constructor-arg>
        <constructor-arg index="3">
            <value>1000</value>
        </constructor-arg>
    </bean>

测试类:

        // 启动IOC容器
        ApplicationContext ac = new ClassPathXmlApplicationContext(
                new String[]{"com/wtu/spring/di/constructor/spring3.0.xml"}
        );

        Boy boy = (Boy) ac.getBean("boyId");
        System.out.println(boy);
        //Boy{id='001', name='小阳', age=16, salary=1000.0}

注入Date类型:
在依赖注入中 如何将一个字符串转换成Date对象, 注入到目标对象

public class Boy {
    private String id;
    private String name;
    private Integer age;
    private Date birthday;
    private Double salary;

    public Boy() {
        System.out.println("Ioc容器创建对象");
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Boy{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", birthday=" + birthday +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}

Spring配置

    <!-- 注册时间格式转换器
        -->
    <bean id="format" class="java.text.SimpleDateFormat">
        <constructor-arg>
            <!-- 时间的格式样式 -->
            <value>yyyy-MM-dd</value>
        </constructor-arg>
    </bean>

    <!-- 注册bean对象
        new SimpleDateFormat("yyyy-MM-dd").parse("2017-12-12"); 
    -->
    <bean id="boy" class="com.wtu.spring.di.set.Boy">
        <property name="birthday">
            <bean factory-bean="format" factory-method="parse">
                <constructor-arg>
                    <value>2017-12-12</value>
                </constructor-arg>
            </bean>
        </property>
    </bean>

测试类:

        // 启动IOC容器
        ApplicationContext ac = new ClassPathXmlApplicationContext(
                new String[]{"com/wtu/spring/di/set/spring3.0.xml"}
        );

        Boy boy = (Boy) ac.getBean("boy");
        System.out.println(new SimpleDateFormat("yyyy-MM-dd").parse("2017-12-12"));
        //Tue Dec 12 00:00:00 CST 2017
        System.out.println(boy);
        //Boy{id='null', name='null', birthday=Tue Dec 12 00:00:00 CST 2017, age=null, salary=null}
DI注解形式

结构.png
UserDaoImpl.java:

public class UserDaoImpl implements UserDao {
    public UserDaoImpl() {
        System.out.println("IOC容器创建对象");
    }

    @Override
    public void addUser() {
        System.out.println("添加用户");
    }
}

UserServiceImpl.java:

public class UserServiceImpl implements UserService {
    private UserDao userDao;

    public UserServiceImpl() {
        System.out.println("IOC容器创建UserServiceImpl对象");
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void addUser() {
        System.out.println("service中addUser方法被调用了");
    }
}

Spring配置:

    <!--注册UserDao对象 -->
    <bean id="userDao" class="com.wtu.spring.di.annotation.UserDaoImpl"/>

    <!--注册UserService对象 -->
    <bean id="userService" class="com.wtu.spring.di.annotation.UserServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>

测试类:

        // 启动IOC容器
        ApplicationContext ac = new ClassPathXmlApplicationContext(
                new String[]{"com/wtu/spring/di/annotation/spring3.0.xml"}
        );

        UserService us = (UserService) ac.getBean("userService");

运行结果:
结果.png

注解改写:
后来的Spring配置文件:

<?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-3.0.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 开启Spring注解的功能 -->
    <context:annotation-config/>
    <!-- 让springIOC容器自动去扫描某一个包, 创建该包下的bean对象 -->
    <context:component-scan base-package="com.wtu.spring.di.annotation2"/>

</beans>

UserDaoImpl.java:

/**
 * @Component(value = "userDao")
 *  告诉SpringIOC容器创建一个id为userDao的bean对象
 *  value可以省略, 但是此时生成的id为类名, 并且首字母小写
 */
//@Component(value = "userDao") // userDaoImpl
@Repository(value = "userDao")
public class UserDaoImpl implements UserDao {
    public UserDaoImpl() {
        System.out.println("IOC容器创建对象");
    }

    @Override
    public void addUser() {
        System.out.println("添加用户");
    }
}

UserServiceImpl.java:

@Service(value = "userServiceImpl")
public class UserServiceImpl implements UserService {
    @Resource(name = "userDao")
//    @Autowired
    private UserDao userDao;

    public UserServiceImpl() {
        System.out.println("IOC容器创建UserServiceImpl对象");
    }

    /*
        spring会自动查找id为userDao的bean对象, 如果找到就通过下面的set方法注入进来
     */
//    @Resource(name = "userDao")
//    public void setUserDao(UserDao userDao) {
//        this.userDao = userDao;
//    }

    @Override
    public void addUser() {
        System.out.println("service中addUser方法被调用了");
    }
}

测试类:

        // 启动IOC容器
        ApplicationContext ac = new ClassPathXmlApplicationContext(
                new String[]{"com/wtu/spring/di/annotation2/spring3.0.xml"}
        );

        UserService us = (UserService) ac.getBean("userServiceImpl");
        us.addUser();

运行结果:
结果.png
注意: @Component现在不提倡使用
对于注册bean对象的注解现在提倡使用如下三个:
@Controller 一般作用在springMVC中
@Service 作用在业务层
@Repository 作用在持久层
但是不是绝对的, 任何一个在任何一层都可以用

AOP

AOP.jpeg

AOP.jpeg

AOP.jpeg
如图上述的解决方案不好：
在javaweb三层框架中，dao层是数据访问层，它的核心业务就是操作数据库，然而像输出时间，开启事务, 日志输出等等。这些事情都不是核心业务，我们可以称之为服务代码，我们不能将执行服务代码这样的事情交给dao层来做。但是我们又需要这样的服务代码。所以我们可以找该类的一个代理对象来实现。

动态代理图解:
动态代理图解.png

动态代理核心代码模拟实现

日志类, 切面:

public class MyLog {
    @SuppressWarnings("deprecation")
    public void writeConsole() {
        System.out.println(new Date().toLocaleString());
    }
}

目标对象所在类, 执行核心代码:

public class UserDaoImpl implements UserDao {

    @Override
    public void addUser() {
        System.out.println("添加用户...");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void deleteUser() {
        System.out.println("删除用户");
    }
}

模拟JDK动态代理的Proxy类:

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

/**
 * 中间类, 相当于JDK动态代理中的Proxy
 * @Author menglanyingfei
 * @Created on 2018.01.17 16:51
 */
public class Middle {
    private UserDao userDao = new UserDaoImpl();
    // 定义切面
    private MyLog myLog = new MyLog();

    public Object getObject() {
        /*
        第一个参数: 当前类的类加载器
        第二个参数: 代理对象实现的接口类型
        第三个参数: 是个接口, 在这个接口中具体去处理如何调用切面以及目标对象
            匿名内部类
         */
        return Proxy.newProxyInstance(
                this.getClass().getClassLoader(),
                userDao.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     *
                     * @param proxy 目标对象
                     * @param method 需要执行目标对象的方法对应的Method对象
                     * @param args 执行目标对象业务方法时需要的参数
                     * @return
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 定义返回值, 目标对象方法执行以后的返回值
                        Object result = "";
                        // 获取目标对象的方法名
                        String methodName = method.getName();
                        if ("addUser".equals(methodName)) {
                            myLog.writeConsole();
                            result = method.invoke(userDao, args);
                            myLog.writeConsole();
                        } else {
                            result = method.invoke(userDao, args);
                        }
                        return result;
                    }
                }
        );
    }

}

测试类:

        // 通过一个中间类来获取代理对象
        Middle middle = new Middle();
        UserDao userDao = (UserDao) middle.getObject();
        userDao.addUser();


        System.out.println(userDao);
        //com.wtu.spring.aop.base.UserDaoImpl@5305068a
        // 红色标识显示
        System.err.println(userDao.getClass());
        // 使用JDK动态代理产生的代理对象
        //class com.sun.proxy.$Proxy0

运行结果:
运行结果.png

导入aop的所需jar包:
jar.png

SpringAOP的五种通知方式

通知就是告诉代理在什么时候去执行服务代码。
1.前置通知: 执行目标对象业务方法之前执行服务代码(切面)
2.后置通知: 执行目标对象业务方法之后执行服务代码
3.方法正常返回通知:
4.方法抛出异常通知:
5.环绕通知:

由于晚上太想睡觉了, 所以只先总结到前置通知, 把剩下的内容留到下次总结吧!
先弄一下前置通知吧!
先定义一个切面: 输出日志时间类

package com.wtu.spring.aop.before;

import java.util.Date;

/**
 * 切面
 * @Author menglanyingfei
 * @Created on 2018.01.17 17:06
 */
public class MyLog {
    @SuppressWarnings("deprecation")
    public void writeConsole() {
        System.out.println(new Date().toLocaleString());
    }
}

目标对象所在类的核心业务代码:

public class UserDaoImpl implements UserDao {

    @Override
    public void addUser() {

//        if (true) {
//            throw new RuntimeException("测试一下遇到异常执行情况");
//        }

        System.out.println("添加用户...");
    }

    @Override
    public void deleteUser() {
        System.out.println("删除用户");
    }
}

Spring配置:

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"

       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.0.xsd

           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
           ">

    <!-- 注册UserDao对象 -->
    <bean id="userDao" class="com.wtu.spring.aop.before.UserDaoImpl">
    </bean>

    <!-- 配置切面 -->
    <bean id="myLog" class="com.wtu.spring.aop.before.MyLog"/>

    <!--
        aop:config: 配置代理对象
        proxy-target-class: 指底层的动态代理使用的是JDK, 还是CGLIB代理;
            true表示CGLIB代理, CGLIB代理不是说没有接口, spring会根据目标对象自动生成一个接口
        aop:pointcut: 配置切入点
        execution: 确定切入点的方法
        aop:aspect: 配置切面如何去切切入点
        pointcut-ref: 切面中的方法去切哪个目标对象中的切入点
    -->
    <aop:config proxy-target-class="true">
        <aop:pointcut expression="execution(* com.wtu.spring.aop.before.UserDaoImpl.a*(..))" id="xxx"/>

        <aop:aspect ref="myLog">
            <aop:before method="writeConsole" pointcut-ref="xxx"/>
        </aop:aspect>
    </aop:config>

</beans>

测试类:

package com.wtu.spring.aop.before;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @Author menglanyingfei
 * @Created on 2018.01.17 14:22
 */
public class TestSpringIoc {
    public static void main(String[] args) {
        // 启动Ioc容器
        ApplicationContext ac = new ClassPathXmlApplicationContext(
                new String[]{"com/wtu/spring/aop/before/spring3.0.xml"}
        );

        UserDao userDao = (UserDao) ac.getBean("userDao");
        userDao.addUser();

        System.out.println(userDao.getClass());
        //class com.wtu.spring.aop.before.UserDaoImpl$$EnhancerByCGLIB$$aa48c241
    }
}

运行结果:
运行结果.png

完整代码地址见Github

https://github.com/menglanyingfei/SSMLearning/tree/master/spring_day02

梦蓝樱飞
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SSM框架归纳学习Spring篇
qq_41227463的博客
02-21 257
Spring是什么？ Spring是一个分层，轻量级兼容性高的一站式(一条龙服务)开源框架。 分层：表现层SpringMVC，业务逻辑层(Dao层)管理事务、记录日志，持久层(数据访问 层)MyBatis。 轻量级：高内聚低耦合 低耦合·对象得创建和依赖关系的维护都交给Spring容器管 理。（IOC控制反转） 兼容性高：面向切面开发（AOP）。 Spring的核心 IOC控制反转...
springmvc 将大写转小写_SpringMVC Jackson 库解析 json 串属性名大小写自动转换问题...
weixin_42628846的博客
12-31 765
问题描述在项目开发中，当实体类和表中定义的某个字段为 RMBPrice，首字母是大写的，sql 查询出来的列名也是大写的 RMBPrice，但是使用 jquery 的 ajax 返回请求响应时却出错，字段名变自动转换成了小写的 rmbprice 了。问题分析将服务器响应 ajax 请求的数据打印出来，字段名仍然是大写的 RMBPrice 。所以，只可能是将 Java 对象转换到 json 串发给客...
在SSM项目中遇到的问题:页面日期格式 显示为英文 Thu Apr 14 00:00:00 GMT+08:00 2022 怎么改成yyyy-MM-dd HH:mm:ss格式
weixin_50875577的博客
04-14 2213
记录自己在学习过程中遇到的各种情况，不足之处，欢迎指正。 前提：本人的页面是在jsp上实现的，更改的方法基于jsp。 第一步:在本 JSP 页面头部加上 fmt 标签 <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %> 第二步:在需要用到时间的地方更改为 原: <td>${bill.getBillTime()}</td> 现在: <td><fmt:for
ssm框架中各层级介绍
最新发布
weixin_72256328的博客
04-09 906
ssm框架中各层级介绍
SSM项目中时间格式问题
Daniel的博客
07-25 975
前言
ssm之八 时间日期格式转换取值
张晨光老师的播客
05-14 2258
在页面上显示所有雇员数据，注意时间格式已经做了转换，点击编辑，去控制器操作<table class="easyui-datagrid" title="雇员" style="width:700px;height:250px" data-options="method:'get',singleSelect:true"> 编号 产品 价格 雇佣时间
第一个SSM项目开发心得
qq_43174927的博客
09-16 1061
文章目录一、项目介绍二级目录三级目录 一、项目介绍   该项目为公司的官方网站，项目分为前台页面和后台页面。前台页面为公司信息展示页面，包括轮播图展示、公司的产品介绍、公司的各种动态等。后台页面为数据管理页面，在此页面能对前台数据进行各种必要的管理。 二级目录 三级目录 ...
SSM 框架整合教程：二、Spring-尚硅谷学习笔记 2022 年
09-08
SSM框架，全称为Spring、SpringMVC和...总的来说，Spring在SSM框架中起着关键的作用，它不仅简化了对象管理，还提供了强大的事务管理和AOP支持。通过深入学习和实践，开发者能够更好地应对复杂的企业级Java Web项目。
SSM框架的学习与应用-Java EE企业级应用开发学习记录-（第六天）初识Spring框架
08-30
本资源是一篇关于学习和应用SSM框架（Spring、SpringMVC、MyBatis）的学习记录系列文章中的第六天内容，主题为初识Spring框架。 在这一部分中，你将了解到Spring框架的基本概念和使用方法，并通过实例探讨了Spring ...
Spring+SpringMVC+Mybatis SSM框架小项目
01-28
SSM框架，即Spring、SpringMVC和Mybatis的整合，是Java开发中常见的Web应用程序框架。这个开源小项目提供了一种便捷的方式，帮助初学者和有经验的开发者理解和实践这三个核心组件的集成。 首先，Spring框架是Java...
spring-ssm 框架整合
09-13
Spring-SSM框架整合提供了完整的Web应用解决方案，通过Spring的IoC和AOP特性，增强了代码的可维护性和可测试性；Struts2实现了MVC模式，简化了控制层的编写；MyBatis简化了数据库操作，使得SQL和Java代码更加清晰。...
ssm学习总结
06-19
SSM（Spring+SpringMVC+MyBatis）框架集由Spring、MyBatis两个开源框架整合而成（SpringMVC是Spring中的部分内容）。常作为数据源较简单的web项目的框架。
ssm之spring总结和整理 java框架
11-07
spring方面介绍 常用注解 生命周期 AOP DI
SSM框架学习心得
weixin_45317524的博客
07-07 4271
1、基本概念 1.1、Spring Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事...
Spring基础：了解IoC容器
Leon_Jinhai_Sun的博客
08-06 156
Spring基础：了解IoC容器
SSM——12.Spring AOP
m0_52096593的博客
11-16 432
问：什么是AOP？在软件行业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程（面向对象编程的缩写：OOP）AOP是一种编程范式，隶属于软工范畴，指导开发者如何组织程序结构AOP最早是由AOP联盟的组织提出的，为此制定了一套规范。Spring将AOP思想引入到框架中,遵守了AOP联盟的规范AOP是通过预编译方式或者运行期动态代理实现程序功能的统一维护的一种技术。
基于ssm实践项目的心得
weixin_41536380的博客
08-21 3512
一、在业务层spring对数据库的事务管理
SSM框架项目总结
热门推荐
平小洁的博客
11-04 1万+
项目流程图 项目总结 经过一个礼拜的SSM框架学习，我已经基本上会使用它来写项目了，非常的方便与好用。 先对于传统的Java Bean + JSP +Servlet模式而言，它有很多的的优点。使用框架 1.不需要创建那么多的Servlet了，看起来很清爽。 2.不需要先数据库JDBC操作了，省略了大量的代码。 我们刚开始使用使用框架，总会遇到各种各样的问题，我做了以下总结。 配置SSM方面 1....
javaSSM 学习笔记spring spring MVC mybatis
11-09
总结来说，Java SSM框架的学习涉及多个层面，从理论理解到实践操作，包括Spring的依赖注入、Spring MVC的请求处理机制，以及MyBatis的SQL映射和数据库交互。通过逐步学习和实践，开发者可以掌握企业级Java Web应用的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值