Spring - 注解&代理模式&AOP

最新推荐文章于 2022-09-28 17:02:49 发布
最新推荐文章于 2022-09-28 17:02:49 发布
阅读量227 收藏 2
点赞数 1
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45988641/article/details/103553626
版权

Spring - 注解 代理模式 AOP

一、Spring与导包

（一）Spring概述

  • 轻量级的DI/IOC与AOP的容器框架

（二）BeanFactory与ApplicationContext的区别

  • ApplicationContext是BeanFactory的子类，它拥有更加强大的一些方法(邮件、国际化…),BeanFactory创建的Bean默认是懒加载,ApplicationContext是迫切加载

（三）Maven导包

1.Spring和AOP需要的包
<dependencies>
    <!--Spring的核心包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>4.2.5.RELEASE</version>
    </dependency>
    <!--Context包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.2.5.RELEASE</version>
    </dependency>
    <!--aop的包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>4.2.5.RELEASE</version>
    </dependency>
    <!--切面的一个包(织入)-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.9</version>
    </dependency>
    <!-- Spring的测试包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>4.2.5.RELEASE</version>
        <!--scope:范围,只能在test包中使用-->
        <scope>test</scope>
    </dependency>
    <!--junit的测试支持-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>
2.引入一些插件与资源
<build>
    <!--JDK1.8版本-->
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>1.8</source>
                <target>1.8</target>
            </configuration>
        </plugin>
    </plugins>
    <!--把配置文件放在java包下面使用(默认不会编译)-->
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.xml</include>
            </includes>
        </resource>
        <resource>
            <directory>src/test/java</directory>
            <includes>
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>
</build>

二、依赖注入

（一）构造参数注入

  • 标签: constructor-arg
1.根据构造器参数的顺序(索引)
<!-- 按照索引注入，索引开始为0 -->
<bean id="myBean" class="com.lty._03constructor.MyBean">
    <constructor-arg index="0" value="猪皮"></constructor-arg>
    <constructor-arg index="1" value="2"></constructor-arg>
</bean>
2.根据构造器参数的名称
<!-- 按照名称注入，名称必须一致 -->
<bean id="myBean" class="com.lty._03constructor.MyBean">
    <constructor-arg name="name" value="猪猪"></constructor-arg>
    <constructor-arg name="age" value="1"></constructor-arg>
</bean>
3.根据构造器的类型注入
<!-- 按照类型注入，必须一一对应，不能有重复的类型-->
<bean id="myBean" class="com.lty._03constructor.MyBean">
    <constructor-arg type="java.lang.String" value="甫甫"></constructor-arg>
    <constructor-arg type="java.lang.Integer" value="3"></constructor-arg>
</bean>
4.自动进行注入
<!-- 按照自动注入，顺序是不允许修改的-->
<bean id="myBean" class="com.lty._03constructor.MyBean">
    <constructor-arg value="中分"></constructor-arg>
    <constructor-arg value="4"></constructor-arg>
</bean>

（二）有一个参数是我们自己的一个对象

1.外部bean引用
<bean id="otherBean" class="com.lty._03constructor.OtherBean"></bean>
<bean id="myBean" class="com.lty._03constructor.MyBean">
    <constructor-arg index="0" value="白白"></constructor-arg>
    <constructor-arg index="1" value="2"></constructor-arg>
    <!--外部bean引用，相当于java中的全局变量，可以重复使用-->
    <constructor-arg ref="otherBean"></constructor-arg>
</bean>
2.内部bean配置
<bean id="otherBean" class="com.lty._03constructor.OtherBean"></bean>
<bean id="myBean" class="com.lty._03constructor.MyBean">
    <constructor-arg index="0" value="白白"></constructor-arg>
    <constructor-arg index="1" value="2"></constructor-arg>
    <!--内部bean配置，相当于java中的局部变量-->
    <constructor-arg>
        <bean class="com.lty._03constructor.OtherBean"></bean>
    </constructor-arg>
</bean>

（三）属性注入

1.普通属性

准备属性

private Long id;
private String name;
private Boolean sex;
private BigDecimal salary;

配置的代码

<property name="id" value="1"></property>
<property name="name" value="猪皮"></property>
<property name="sex" value="true"></property>
<property name="salary" value="3000"></property>
2.集合属性
▪ List< String>

准备属性

private List<String> list;

配置的代码

<!--List<String> list:有序可重复-->
<property name="list">
    <list>
        <value>甫甫</value>
        <value>白白</value>
        <value>中分</value>
    </list>
</property>
▪ Set< String>

准备属性

private Set<String> set;

配置的代码

<!--Set<String> set：无序不可重复-->
<property name="set">
    <set>
        <value>金木研</value>
        <value>利世</value>
        <value>董香</value>
    </set>
</property>
▪ List< OtherBean>

准备属性

private List<OtherBean> otherBeanList;

配置的代码

<!--List<OtherBean> otherBeanList
	有4个值，外部引用的地址值一样
-->
<property name="otherBeanList">
    <list>
        <!--内部引用-->
        <bean class="com.lty._04di.OtherBean"></bean>
        <bean class="com.lty._04di.OtherBean"></bean>
        <!--外部引用-->
        <ref bean="otherBean"></ref>
        <ref bean="otherBean"></ref>
    </list>
</property>
▪ Set< OtherBean>

准备属性

private Set<OtherBean> otherBeanSet;

配置的代码

<!--Set<OtherBean> otherBeanSet
	有3个值，外部引用的地址值只显示了一个
-->
<property name="otherBeanSet">
    <set>
        <bean class="com.lty._04di.OtherBean"></bean>
        <bean class="com.lty._04di.OtherBean"></bean>
        <!--外部引用-->
        <ref bean="otherBean"></ref>
        <ref bean="otherBean"></ref>
    </set>
</property>
▪ Map<String,Integer>

准备属性

private Map<String,Integer> map;

配置的代码

<!--Map<String,Integer> map-->
<property name="map">
    <map>
        <entry key="银时" value="2"></entry>
        <entry key="神乐" value="4"></entry>
        <entry key="新八" value="6"></entry>
    </map>
</property>
3.数组属性

准备属性

private String[] arrays1;
private String[] arrays2;

配置的代码

<!--String[] arrays1:标准写法-->
<property name="arrays1">
    <array>
        <value>夏</value>
        <value>木</value>
    </array>
</property>
<!--String[] arrays2：简写形式-->
<property name="arrays2" value="喵咪,老师"></property>
4.Properties属性

准备属性

private Properties props1;
private Properties props2;

配置的代码

<!--Properties props1：标准写法-->
<property name="props1">
    <props>
        <prop key="username">童</prop>
        <prop key="password">123456</prop>
    </props>
</property>
<!--Properties props2：简写形式(不支持中文，可以把等号换成空格)-->
<property name="props2">
    <value>
        username=瑶
        password=112233
    </value>
</property>

三、XML自动注入(了解)

  • 自动注入有两种方式 (类型与名称)
  • 设置全局的自动注入 <beans ... default-autowire="byType/byName">
  • 单独为某一个bean配置自动注入 <bean ... autowire="byType/byName">

四、全注解

1.配置context命名空间

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

2.配置让Spring扫描类与支持注解

<context:component-scan base-package="com.lty._05anno"></context:component-scan>

3.在相应的类上加注解

  • @Controller：控制层
  • @Service：业务层
  • @Repository：持久层
  • @Component:组件(一个bean不知道在哪一层用这个)
  • @Autowired:注入功能

4.解决接口有多个实现

▪ 先类型注入，再根据名称注入
@Service
public class UserServiceImpl implements IUserService {
    /*注解的bean有默认名称,实现类名称首字母小写*/
    @Autowired
    IUserDao userDaoJDBCImpl;
}
▪ 修改bean的名称
@Repository("userDaoJDBC")
public class UserDaoJDBCImpl implements IUserDao{

    @Override
    public void save() {
        System.out.println("UserDaoJDBCImpl : save");
    }
}
@Autowired
    IUserDao userDaoJDBC;
}
▪ 在注入bean的时候加上一个限定注解
@Service
public class UserServiceImpl implements IUserService {
    @Autowired
    @Qualifier("userDaoJDBC")
    IUserDao userDaoJDBCImpl;
}
▪ 使用@Resource
@Service
public class UserServiceImpl implements IUserService {
    @Resource(name = "userDaoJDBCImpl")
    IUserDao userDao;
}

五、代理模式

  • 开发术语：抽象主题角色、代理主题（Proxy）角色、真实主题角色
  • 分为静态与动态
  • Spring使用的是动态代码:JDK(接口)/CGLIB
  • 动态代理的代码
//通过JDK的方案创建一个动态代理对象呢
/**
 * Foo f = (Foo) Proxy.newProxyInstance(
   Foo.class.getClassLoader(),
   new Class[] { Foo.class },
   handler);
 */
/**
 * newProxyInstance:创建代理对象
 *      参数一 ClassLoader loader :传入类加载器(随便找一个给它就可以)
 *      参数二  Class<?>[] interfaces:抽象主题角色(就是接口对应的类)
 *             userService.getClass().getInterfaces()
 *      参数三  InvocationHandler h:处理器(由我们自己实现)
 */
IUserService proxy = (IUserService)Proxy.newProxyInstance(
    ProxyTest.class.getClassLoader(),
    userService.getClass().getInterfaces(),
    new InvocationHandler() {
        //实现的代码
        /**
         * @param proxy : 代理对象(不用它)
         * @param method : 执行方法
         * @param args : 执行方法的参数
         */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object result = null;
            try {
                txManager.begin();
                //通过反射执行方法
                result = method.invoke(userService, args);
                txManager.commit();
            } catch (Exception e) {
                txManager.rollback();
                e.printStackTrace();
            }  finally {
                txManager.close();
            }
            return result;
        }
    }
);
proxy.save();
}

六、Spring的AOP

  • 可以用于事务管理、日志管理、性能监测等
  • Spring实现Aop有两种方案：JDK(若目标对象实现了若干接口)与CGLIB(若目标对象没有实现任何接口)

（一）Xml版实现AOP

准备接口:IUserService

public interface IUserService {
    void save();
    void delete();
}

准备实现 UserServiceImpl

public class UserServiceImpl implements IUserService {
    @Override
    public void save() {
        System.out.println("UserServiceImpl:save");
    }

    @Override
    public void delete() {
        System.out.println("UserServiceImpl:delete");
        int i = 1 / 0;
    }

}

事务管理器对象(模拟的)

public class TxManager {
    public void begin(){
        System.out.println("开启事务");
    }
    public void commit(){
        System.out.println("提交事务");
    }
    public void rollback(Throwable throwable){
        System.out.println("回滚事务    原因 : " + throwable.getMessage());
    }
    public void close(){
        System.out.println("关闭事务");
    }
    
}
1.添加aop命名空间
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
">
2.准备两个bean
<!--创建一个业务对象-->
<bean id="userService" class="com.lty._01aopxml.service.impl.UserServiceImpl"></bean>
<!--创建一个事务对象-->
<bean id="txManager" class="com.lty._01aopxml.TxManager"></bean>
3.xml配置
<aop:config>
    <!--
            aop:pointcut  配置切点
                id  切点名称(可以随便取)
                expression  表达式execution()，定位到接口它的实现也全部找到
                    *:任意返回值
                    com.lty._01aopxml.service:定位的包名
                    I*Service:以I开始以Service结尾的所有接口类
                    *:任意方法
                    (..):任意参数
        -->
    <aop:pointcut id="pointcut" expression="execution(* com.lty._01aopxml.service.I*Service.*(..))"></aop:pointcut>
    <!--
            aop:aspect  切面(由切点与增强【通知】组成)
            ref="txManager"  引入增强的类
            	何地:在哪些类的哪些方法中:pointcut
            	何时:在方法执行之前:before
            	做什么事:执行txManager这个bean中的方法
        -->
    <aop:aspect ref="txManager">
        <!-- 前置通知 -->
        <aop:before method="begin" pointcut-ref="pointcut"></aop:before>
        <!-- 后置通知 -->
        <aop:after-returning method="commit" pointcut-ref="pointcut"></aop:after-returning>
        <!-- 异常通知(异常抛出去才能使用) -->
        <aop:after-throwing method="rollback" pointcut-ref="pointcut" throwing="throwable"></aop:after-throwing>
        <!-- 最终通知 -->
        <aop:after method="close" pointcut-ref="pointcut"></aop:after>
    </aop:aspect>
</aop:config>
环绕通知
  • 前面的4个通知就不用了，其他一样

事务管理器对象(模拟的)

public class TxManager {
    public void begin(){
        System.out.println("开启事务");
    }
    public void commit(){
        System.out.println("提交事务");
    }
    public void rollback(Throwable throwable){
        System.out.println("回滚事务    原因 : " + throwable.getMessage());
    }
    public void close(){
        System.out.println("关闭事务");
    }

    /*环绕通知*/
    public void around(ProceedingJoinPoint joinPoint){
        try{
            begin();
            //执行方法
            joinPoint.proceed();
            commit();
        }catch (Throwable throwable){
            rollback(throwable);
            throwable.printStackTrace();
        }finally {
            close();
        }
    }
}

xml配置

<aop:aspect ref="txManager">
    <!--环绕通知（可以自己控制执行顺序）-->
    <aop:around method="around" pointcut-ref="pointcut"></aop:around>
</aop:aspect>

（二）注解版实现AOP

  • 需要在相应的bean上加注解
  • 配置包的扫描
  • 所有的配置都是在TxManager加注解

xml配置

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

    <!--开启扫描包-->
    <context:component-scan base-package="com.lty._02aopanno"></context:component-scan>
    <!--支持AOP注解-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

事务管理器TxManager

  • 切点的名字是方法名()
/**
 * @Aspect = <aop:aspect ref="txManager">
 */
@Component
@Aspect
public class TxManager {
    /*配置一个切点（随便写个方法）
     *<aop:pointcut id="pointcut()" expression="execution()"></aop:pointcut>
     */
    @Pointcut("execution(* com.lty._02aopanno.service.I*Service.*(..))")
    public void pointcut(){

    }
    /*<aop:before method="begin" pointcut-ref="pointcut"></aop:before>*/
    @Before("pointcut()")
    public void begin(){
        System.out.println("开启事务");
    }
    /*<aop:after-returning method="commit" pointcut-ref="pointcut"></aop:after-returning>*/
    @AfterReturning("pointcut()")
    public void commit(){
        System.out.println("提交事务");
    }
    /*<aop:after-throwing method="rollback" pointcut-ref="pointcut" throwing="throwable"></aop:after-throwing>*/
    @AfterThrowing(value = "pointcut()",throwing = "throwable")
    public void rollback(Throwable throwable){
        System.out.println("回滚事务    原因 : " + throwable.getMessage());
    }
    /*<aop:after method="close" pointcut-ref="pointcut"></aop:after>*/
    @After("pointcut()")
    public void close(){
        System.out.println("关闭事务");
    }
}
环绕通知
  • 要把其它几个通知的注解去掉(不然会出现重复)
/**
 * @Aspect = <aop:aspect ref="txManager">
 */
@Component
@Aspect
public class TxManager {
    public void pointcut(){}
    
    public void begin(){
        System.out.println("开启事务");
    }

    public void commit(){
        System.out.println("提交事务");
    }

    public void rollback(Throwable throwable){
        System.out.println("回滚事务    原因 : " + throwable.getMessage());
    }

    public void close(){
        System.out.println("关闭事务");
    }

    /*环绕通知
     *<aop:around method="around" pointcut-ref="pointcut"></aop:around>
     */
    @Around("pointcut()")
    public void around(ProceedingJoinPoint joinPoint){
        try {
            begin();
            joinPoint.proceed();
            commit();
        }catch (Throwable throwable){
            rollback(throwable);
            throwable.printStackTrace();
        }finally {
            close();
        }
    }
}

七、创建Bean的方式

（一）实例化一个有公共无参构造的方式

<bean id="myBean" class="cn.itsource._09_createbean._01_base.MyBean" />

（二）FactoryBean方式

  • 一个类实现了FactoryBean接口
  • 执行getObject方式，返回的值也会变成一个Bean

准备一个FactoryBean

/**
 * 一个类实现FactoryBean接口，那么它就是一个FactoryBean
 *  泛型就是它要操作的那个类型
 */
public class EntityManagerFactoryBean implements FactoryBean<EntityManagerFactory> {

    //这个方法返回什么对象，我们拿到的bean就是什么对象
    @Override
    public EntityManagerFactory getObject() throws Exception {
        return Persistence.createEntityManagerFactory();
    }

    //返回的对象类型
    @Override
    public Class<?> getObjectType() {
        return EntityManagerFactory.class;
    }

    //这个对象是否是单例的
    @Override
    public boolean isSingleton() {
        return true;
    }
}

配置对应的方法

<bean id="entityManagerFactory" class="cn.itsource._09_createbean._02_factorybean.MyEntityManagerFactoryBean">
</bean>
BeanFactory与FactoryBean的区别
  • BeanFactory接口 ： 顶层父工厂,容器,获取bean的实例
  • FactoryBean接口：实例化不能通过默认无参构造方法获取的bean，通过子类的getObject方法来返回实例

（三）集成静态简单工厂

  • 工厂中有一个静态方法
  • 直接拿到这个方法中返回的对象(bean)

准备一个静态工厂

public class DaoFactory {
    //在这个工厂中有一个静态方法
    public static MyDao createMyDao(){
        return new MyDao();
    }
}

配置这个工厂对应的方法

<bean id="myDao" class="cn.itsource._10_bean.DaoFactory"factory-method="createMyDao"></bean>

（四）集成实例简单工厂

  • 工厂中有个方法
  • 直接拿到这个方法中返回的对象(bean)

准备一个静态工厂

public class DaoFactory {
    public MyDao createMyDao(){
        return new MyDao();
    }
}

配置这个工厂对应的方法

<!--工厂的一个方法(非静态)-->
<bean id="daoFactory" class="cn.itsource._10_bean.DaoFactory" />
<bean id="myDao" factory-bean="daoFactory" factory-method="createMyDao" />
EstherLty
关注
专栏目录
Spring Boot - spring-boot-starter-aop
学无止境
06-12 1086
然后，我们创建了一个切面类LoggingAspect，它使用@Before和@After注解来定义前置通知和后置通知，这些通知将在UserService类的getUser()在工作中，spring-boot-starter-aop常用于在应用程序中实现切面编程，例如日志记录、性能监控、事务管理等。最后，在Application类的main()方法中，我们获取UserService的实例并调用getUser()方法。在这个示例中，我们创建了一个UserService类，它有一个getUser()
Spring 学习 day2 : Spring注解和代理模式
whosedad的博客
12-29 1007
1.IOC注解 Spring框架中有注解和XML两种配置方式,这两种方式各有千秋 1.1 xml和注解两种注解方式的区别 1.1.1 XML配置 优点有: 1.XML配置方式进一步降低了耦合,使得应用更加容易扩展,即使对配置文件进一步修改也不需要工程进行修改和重新编译 2.在处理大的业务量的时候,用XML配置应该更好一些,因为XML更加清晰的表明了各个对象之间的关系,各个业务类之间的调用,同时Spring的相关配置也能一目了然. 缺点有: 配置文件读取和解析需要花费一定的时间,配置文件过多的
Spring注解&代理模式&AOP
风华流沙君莫笑的博客
01-16 365
文章目录Day40 Spring注解&代理模式&AOPSpirng注解什么是SpringSpring的两大核心编程思想依赖注入普通注入XML方式自动注入全注解注入@Autowired 与 @Resource的区别AOP代理模式分类AOP术语(了解)配置静态代理AOP的配置 Day40 Spring注解&代理模式&AOP Spirng注解 什么是Spring Spr...
基于SSJ智能销售系统的模版开发-01
kls_larson的博客
04-01 196
一.SpringDataJpa SpringData -> SpringDataJpa:操作数据库变得更好简单 1.pom.xml配置 - 1.基本的SSJ的导入 - 2.SpringDataJpa <dependency> <groupId>org.springframework.data</groupId> ...
注解 以及Java 中的代理模式及动态代理
jinxupup的博客
06-13 326
注解 https://blog.csdn.net/briblue/article/details/73824058代理模式 https://blog.csdn.net/briblue/article/details/73928350
SpringBoot Service层常用注解
a519525531的博客
06-07 4186
@Service：用于标注业务层组件，默认名称为类名。 @Slf4j：用作日志输出，在该类添加了该注释之后，就可以在代码中直接引用log.info( ) 打印日志了，该注解需要lombok插件 @Transactional:是声明式事务管理，在接口实现类或接口实现方法上添加，只有public的方法才起作用，只读的接口不需要使用事务接口。 ...
Spring——AOP用到的代理模式&SpringAOP实现原理
娜娜米的博客
07-04 2364
AOP，面向切面编程，是Spring框架中的核心思想之一；在Spring中是通过动态代理来实现的，在目标类的基础上增加切面逻辑，对原对象进行增强； SpringAOP的源码中用到了两种动态代理来实现拦截切入功能：JDK动态代理和CGlib动态代理，两种方法的适用条件和效率各有不同，各有优劣； 本来准备写一篇关于SpringAOP相关的文章的，这篇文章介绍，作为Spring AOP的基础知识，介绍代理设计模式以及Java中的几种不同的代理模式的实现：静态代理、JDK动态代理和CGlib代理；.........
spring-aop-jar
12-14
在Spring AOP中，切面可以通过注解或XML配置来定义。 - 连接点（Join Point）：连接点是程序执行过程中的一个特定点，例如方法的调用或字段的访问。 - 切入点（Pointcut）：切入点是连接点的集合，定义了切面将在...
SpringBoot-事务&AOP-黑马程序员学习笔记
最新发布
05-21
在Spring中，AOP通过代理模式实现，分为JDK动态代理和CGLIB代理。 1. **切面（Aspect）**：定义了关注点的模块化，包含通知（Advice）和切点（Pointcut）。 2. **通知（Advice）**：在特定连接点执行的代码，如前置...
Java Spring代理模式AOP-IOC分析
10-01
Java Spring代理模式AOP-IOC分析 一、代理模式概述 在软件设计中，代理模式是一种常用的设计模式。它可以在不修改原始代码的情况下，扩展或修改原始对象的行为。代理模式可以分为静态代理和动态代理两种。静态代理...
spring-boot aop
01-23
Spring Boot AOP（面向切面编程）是一种强大的设计模式，它允许我们在不修改现有代码的情况下，插入额外的功能或监控代码。在Spring框架中，AOP主要用于日志记录、事务管理、性能统计等场景。本示例是关于如何在...
JAVA注解、自定义注解及代理模式
Kfie66的博客
08-24 966
注解 注解的作用 1.生成文档 2.可以在编译期做标示或者检查的作用。 3.分析代码----&gt;注解的解析 jdk中的三个基本注解 自定义注解 public @interface 注解名{} 注解属性("类型 属性名()") 八种基本数据类型 String 枚举类型 注解类型 Class类型 以上类型...
Annotation自定义注解与代理模式
u011573295的博客
04-30 575
需求：利用自定义注解实现代理类生成时，按照注解获取被代理类 消息接口和两个实现类： interface IMessage{ void send(); } class MessageImpl1 implements IMessage { @Override public void send(){ System.out.println("发送消息1"); ...
Spring-注解&代理模式&AOP
Aydxz的博客
03-29 371
Spring+SpringMVC+SpringDataJpa： 一.Spring的回顾 概述：Spring是一个轻量级的DI/IOC与AOP的容器框架 BeanFactory与ApplicationContext的区别? 都是接口，ApplicationContext是BeanFactory的子接口,拥有更多的功能与方法。ApplicationContext是在启动容器创建上下文环境的时候...
判断字符串是否为空
热门推荐
EstherLty的博客
01-11 1万+
一、判断一个字符串为空的方法有： str == null || "".equals(str); str == null || str.length() == 0; str == null || str.isEmpty(); 注意： 1）length是属性，一般集合类对象拥有的属性，取得集合的大小。  例如：数组.length就是取得数组的长度。 2）length()是方法，一般字符串类对象有该方法，也是取得字符串长度。  例如：字符串.length(); 说明： null表示这个字符串不指
LambdaQueryWrapper
EstherLty的博客
08-21 1万+
LambdaQueryWrapper条件构造器方法对应Sql setSqlSelect SELECT 查询字段 举例 where WHERE 语句，拼接 + WHERE 条件 and AND 语句，拼接 + AND 字段=值 andNew AND 语句，拼接 + AND (字段=值) or OR 语句，拼接 + OR 字段=值 .eq(" name “,” 木 子 “). or ( ). eq (” id ", 1 ) => name=“木子” or id=1
Java保留小数点后两位
EstherLty的博客
09-28 8663
Java保留小数点后两位。
Eclipse报错:An error has occurred.See error log for more details.
EstherLty的博客
07-07 7722
**原因分析：**这个错误表示你的eclipse的某个功能出现了异常，这个时候，我们只需要cmd进入eclipse的eclipse.exe存放的位置，执行：,等eclipse自动重启完成就能够恢复它的正常功能了。执行完这个命令后你的eclipse相当于重新安装的，什么也没有了，需要重新导入项目下载插件。.........
windows中tomcat查看和杀死进程
EstherLty的博客
07-08 6165
1.快捷键windows+R2.输入cmd3.查询tomcat进程 4.输入taskkill /F /PID 16828（杀掉对应进程） 要把后面的进程号全部杀死才行（16828、17500），直到输入上面第三个命令查不到占用8080端口号的进程号为止
spring-aop与spring-boot-starter-aop的区别
09-22
spring-aop与spring-boot-starter-aop的区别在于配置的简化程度和依赖的引入方式。spring-aop是基于Spring框架的AOP实现方式，需要通过XML配置文件来定义切面和通知。而spring-boot-starter-aop是针对Spring Boot应用程序提供的一种简化配置和使用的方式，可以通过注解和Java配置来定义切面和通知。使用spring-boot-starter-aop可以更方便地进行AOP操作，并且不需要额外引入独立的AOP依赖。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值