新浦京81707con > 软件下载 > 澳门葡京网站最基本的理解,Spring_Aop的xml和注解

原标题:澳门葡京网站最基本的理解,Spring_Aop的xml和注解

浏览次数:150 时间:2019-10-27

生手对spring aop 最主旨的敞亮。以致利用,springaop

  第1回写博客。本人是个生手。有啥窘迫的地方请指正。发那些博客只是为了收拾本人的求学进程。以至部分主见。

  下边起头正文:(这么些事物摘自洋匈牙利人的博客,最终本身总括的,有如何窘迫之处请指教。)

   oop是多少个由上至下的竖向编制程序,aop是横向的切入。

*  OOP允许你定义从上到下的涉嫌,但并不契合定义从左到右的涉及。举例日志效能。日志代码水平地布满在具备目的档次中,而与它所传布到的目的的主导功用毫非亲非故系,导致了汪洋代码的双重。
  aop剖解三明装的靶子内部,并将那么些影响了多少个类的公共行为封装到二个可选取模块,并将其名字为“Aspect”,也正是‘方面’。他能够下跌模块间的耦合度,并方便未来的成效的修改和保险。*

  简单的说:就是领取公共代码(日志,权限),放到一齐,方便飞快。

福寿双全AOP的本领,首要分为两大类:一是运用动态代理技术jdk 或是 cglib,二是行使静态织入的艺术,使编写翻译器能够在编写翻译时期织入有关“方面”的代码。作者日常在类型在中间用的便是动态代理。

配备文件 方式的aop 可用以日志,事务的操纵

<!-- 系统服务组件的切面Bean -->
<bean id="serviceAspect" class="cn.ysh.studio.spring.aop.aspect.ServiceAspect"/>
<!-- AOP配置 -->
<aop:config>
<!-- 声贝拉米(Bellamy)个断面,并流入切面Bean,也正是@Aspect -->
<aop:aspect id="simpleAspect" ref="serviceAspect">
<!-- 配置三个切入点,相当于@Pointcut -->
<aop:pointcut expression="execution(* cn.ysh.studio.spring.aop.service..*(..))" id="simplePointcut"/>
<!-- 配置文告,约等于@Before、@After、@AfterReturn、@Around、@AfterThrowing -->
<aop:before pointcut-ref="simplePointcut" method="before"/>
<aop:after pointcut-ref="simplePointcut" method="after"/>
<aop:after-returning pointcut-ref="simplePointcut" method="afterReturn"/>
<aop:after-throwing pointcut-ref="simplePointcut" method="afterThrow" throwing="ex"/>
</aop:aspect>
</aop:config>

 

依据证明 的aop
在计划文件中 注脚激活自动扫描组件成效,同期激活自动代理成效

<!-- 激活零部件扫描功效,在包cn.ysh.studio.spring.aop及其子包上边自动扫描通过申明配置的组件 -->
<context:component-scan base-package="cn.ysh.studio.spring.aop"/>
<!-- 激活自动代理功效 -->
<aop:aspectj-autoproxy proxy-target-class="true"/>

//阐明这是一个零部件
@Component

//注解那是二个断面Bean
@Aspect

//配置切入点,该办法无方法体,主要为平价同类中别的办法应用此处配置的切入点
@Pointcut("execution(* cn.ysh.studio.spring.aop.service..*(..))")
public void aspect(){ }

/*
* 配置前置文告,使用在点子aspect()上登记的切入点
* 同期选拔JoinPoint切入点对象,能够未有该参数
*/
@Before("aspect()")

//配置前置文告,使用在措施aspect()上注册的切入点
@After("aspect()")

//配置环绕公告,使用在章程aspect()上注册的切入点
@Around("aspect()")

//配置前置重回文告,使用在点子aspect()上注册的切入点
@AfterReturning("aspect()")

//配置抛出非常后通告,使用在情势aspect()上注册的切入点
@AfterThrowing(pointcut="aspect()", throwing="ex")

 

 

  

 

   

aop 最中央的敞亮。以至利用,springaop 第一遍写博客。本身是个新手。有怎么着窘迫之处请指正。发这些博客只是为着整理本人...

动态代理:

编程步骤:annotation

    目标:在不改造源代码的景况下,对章程实行加强!
    
    动态代理又分为二种:
    1.首先个便是依照接口的动态代理,他是由jdk提供的
    2.基于子类的动态代理:cglib提供的:要想利用基于子类的动态代理:就亟须得导入cglib的jar包
    
    本性:被代理对象的自由方法     

  1.    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

Spring_aop:总结
aop(Aspect Oriented Programming) :面向切面编制程序

2.加切面@Aspect

断面:相对于事情主线的附加的功能模块
在不改换程序源代码的景色下对议程进行抓实

3.加组件@Component

aop的底层原理便是动态代理
    aop的底部他会自动的依据代码,选拔是行使基于依然利用子类的动态代理!
    
    使用aop举办编制程序有甚好处呢?
        1.简化业务代码
        2.保安轻松
        
        Aop相关术语
        Joinpoint(连接点):奉行的方法
        pointcut(切入点):被拉长的点子
        Advice(通告/加强):正是极度的成效模块
            前置布告
            前置公告
            分外文告
            最终文告
            环绕通告
            Aspect(切面):
                对这二个情势开展什么样的增长
        学习Aop珍视关切的专门的学业是甚呢?
        1.第后生可畏关心的是三个一个的额外的作用模块
        2.aop的配置
其三 spring Aop的开荒流程
            定义多少个切面类
            普通的Java类,在这里个类中经过多少个贰个的主意对目的对象进行抓牢
            
            2.配置Aop
                在xml里面配备文件中aop
                i.将切面类交给spring管理
                
                ii.声明Aop配置
                <aop:config>
                iii.定义切入点
                aop:pointcut
                iiii.定义通知类型
                <aop:aspect ref = "切面类的援引">
                    前置公告
                    <aop:before method="切面类的诀要名" pointcut-ref="切入点表明式是援引"/>
                    前置文告<aop:afterRunturning method="切面类的方法名" pointcut-ref="切入点表明式是引用"/>
                    分外公告<aop:after-throwing method="切面类的章程名" pointcut-ref="切入点表达式是援用"/>
                    最终文告<aop:after method="切面类的法子名" pointcut-ref="切入点表达式是援引"/>
                    注意:格外文告独有现身了非常了 才会有打招呼
                </aop:aspect>
                基于注解的Aop配置(结合xml)
            1.将切面类交给spring管理
            2.接收表明的款型取代xml中的aop的布署
            3.利用表明配置spring的ioc只怕aop的时候都亟待敞开对声明的扶助!
            
            注意:使用表明配置Aop和xml配置Aop在前置通告的时候,有意气风发对出入!
            评释的安顿:是最终试行后置布告!
            
            纯表明配置Aop
            1.宣称配置类
            2.开启对ioc的支持
            3.展开对aop注明的帮助
            @EnableAspectJAutoProxy
            
付出步骤以至代码的表达
        <!-- 将切面类交给spring管理 -->
        <bean id="logger" class="cn.itcast.utils.Logger"></bean>
        
        <!-- 表明AOP配置:须要动用aop的命名空间(必得导入aop的自律)
        aop:config : 声明aop配置
     -->
    <aop:config>
    
    <!-- 定义切入点:定义被升高的秘诀
            expression : execution(类的修饰符 重返值 包名.包名...类名.方法名(参数列表))
            1.类的修饰符能够省略 :重临值 包名.包名...类名.方法名(参数列表)
            2.再次来到值能够使用*号替代:标记任意重临值都得以
            3.包名得以行使*号取代,一个包须要二个*
            4.包名..代表此包   以致   此包的任特性包
            5.类名能够行使*取代他,代表猖狂类
            6.方法名能够利用*代办,代表私自方法
            7.参数体系能够采用..代表专断参数
            
            **** 此写法 * *..*.*(..) 不推荐
            
         -->
        <aop:pointcut expression="execution(* cn.itcast.service.impl..*.*(..))" id="pt"/>
        
        
        
        <!-- 配置切面
                aop:aspect
                    ref:被spring管理的切面类的援引
        -->
        <aop:aspect ref="logger">
        
        
            <!-- 定义公告的类型
                aop:before  定义前置公告
                    method:切面类中定义的方式名
                    pointcut-ref:切入点表明式是援引
            -->
            <aop:before method="before" pointcut-ref="pt"/>
            
            那是xml里面包车型大巴配置
            
注脚协作xml使用代码以至分解
    <!-- 开启对spring ioc的支持 -->
    <context:component-scan base-package="cn.itcast"></context:component-scan>
    
    <!-- 开启对aop注明的支撑 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
    
    /*
 * 切面类:
 *         对目的对象举行日志部分的增长是经过此类中的方法来贯彻
 * 在切面类上
 *         定义切面类
 * 在切面方法上
 *         使用注明的形式定义布告类型
 */
@Component("logger")
@Aspect
public class Logger {//这是布局到类上的

  1.    加切入点@Pointcut ("execution(public* com.service..*.add(..))")

/**
     * 抽出切入点表达式
     *         @Pointcut:定义切入点表达式
     *             那个注明须求安顿到方法上,那一个主意是三个空的章程
     *             应用这几个切入点表明式的时候,只需求引进方法名就能够了
     *             不过内需  方法名()   须要加括号
     */
    @Pointcut(value="execution(* cn.itcast.service.impl..*.*(..))")//注意:类名前边那八个点改成多少个点也是能够的
    @Pointcut(value="execution(* cn.itcast.service.impl.*.add*(..))")//那是钦定对特别情势进行抓实
    public void pt() {//定义三个通用的,那样后置布告,前置公告等等用的时候只需求引用那些点子名就行了
        
    }
    
    /**
     * 定义前置公告
     *     @Before :
     *         value : 能够是贰个切入点表明式,也足以是二个切入点表明式的援用
     *             切入点表明式    
     */
    @Before("pt()")
    public void before() {
        System.out.println("踏向形式早前打字与印刷日志");
    }
    
            
    *那是证明配置xml的情势

Xml:方法一:

纯注脚的配备情势

<bean id= "logInterceptor" class="com.*.aop.LogInterceptpr"></bean>

/*
 * 切面类:
 *         对指标对象开展日志部分的增高是通过此类中的方法来促成
 * 在切面类上
 *         定义切面类
 * 在切面方法上
 *         使用证明的款式定义通告类型
 */
@Component("logger")
@Aspect
public class Logger {
    
    /**
     * 抽取切入点表达式
     *         @Pointcut:定义切入点表达式
     *             那些申明须求配备到点子上,那些办法是三个空的法子
     *             应用那个切入点表明式的时候,只供给引进方法名就能够了
     *             不过要求  方法名()   须求加括号
     */
    @Pointcut(value="execution(* cn.itcast.service.impl..*.*(..))")
    public void pt() {
        
    }
    
    /**
     * 定义前置通告
     *     @Before :
     *         value : 能够是二个切入点表明式,也得以是一个切入点表明式的援引
     *             切入点表达式    
     */
    @Before("pt()")
    public void before() {
        System.out.println("步向艺术以前打字与印刷日志");
    }
    
    
    @AfterReturning("pt()")
    public void afterReturning() {
        System.out.println("推行对象措施得到重临值后打字与印刷日志");
    }
    
    @AfterThrowing("pt()")
    public void afterThrowing() {
        System.out.println("抛出非凡打字与印刷日志");
    }
    
    @After("pt()")
    public void after() {
        System.out.println("在最终代码块中打字与印刷日志");
    }
    
    //5.定义环绕布告
    /**
     * 环绕通告是spring提供的意气风发种
     *     让技术员手动钦命要实践的拉长方法的意气风发种花招,
     * 在那方法中得以凭仗须要自定义以上4中通报类型
     *     在围绕通告中,要求手动去调用被拉长的秘诀
     *     依据spring提供的一个对象ProceedingJoinPoint
     *             此对象中有多个主意,能够调用被升高的方法
     *         pjp.proceed();实践被增加的的主意
     *             eg:动态代理中的,method.invoke();
     *
     * @throws Throwable
     */
    @Around("execution(* cn.itcast.service.impl..*.*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("前置布告");
        Object obj = null;
        try{
            obj = pjp.proceed();
            System.out.println("前置通告");
        }catch(Exception e){
            System.out.println("分外通知");
            e.printStackTrace();
        }finally{
            System.out.println("最后公告");
        }
        return obj;
    }
}

    <!-- 切面配置 -->

/spring的配置类
//在布署类中替换xml配置文件中的剩余配置项

    <aop:config>

/**
 * 1。证明配置类
 * 2。开启对ioc的支持
 * 3。开启对AOP注解的接济
 *         @EnableAspectJAutoProxy
 *
 */
@Configuration
@ComponentScan(basePackages="cn.itcast")
@EnableAspectJAutoProxy
public class Config {

    <!-- 内定切入点表达式,钦命哪些指标对象或对象方法被切入 -->

}

        <aop:pointcut expression="execution(public *com.*.service..*.add(..))" id="servicePointcut"/>

    public class Client {

        <!-- 内定logAspect为切面组件 -->

    public static void main(String[] args) {
        //测试ioc的配置
        //ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        ApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);
        
        CustomerService customerService = (CustomerService)ac.getBean("customerService");
        customerService.updateCustomer();
    }
}
        那是纯注脚的章程
        
        Aop事物案例
        
        @Component("logger")
@Aspect
public class Logger {
    
    @Pointcut(value="execution(* cn.crm.service.impl..*.*(..))")
    public void pt(){
        
    }
    
    @Around(value="pt()")
    public Object tx(ProceedingJoinPoint pjp) throws Throwable{
        Session session = null;
        Transaction tx = null;
        
        Object obj = null;
        
        try {
            session = HibernateUtils.getCurrentSession();
            tx = session.beginTransaction();
            
            obj = pjp.proceed();
            
            tx.commit();
            
        } catch (Exception e) {
            System.out.println("现身万分了");
            tx.rollback();
            
        }finally {
            
            System.out.println("最终实践的代码");
            
        }
        
        return obj;
        
    }     

        <aop:aspect id="logAspect" ref="logInterceptor">

}

           <aop:before method="before" pointcut-ref="servicePointcut"/>

    public class Client{
        public static void main(String[] args) {
        
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        
        CustomerService customerService = (CustomerService)ac.getBean("customerService");
        
        
        Customer customer = new Customer();
        
        customer.setCustName("hello");
        
        customerService.addCustomer(customer);
    }
        
    }

        </aop:aspect>

        xml配置:
         <context:component-scan base-package="cn.crm"></context:component-scan>
        
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
        
        
        
        那是三个微小Aop的事物案例,当然Spring也提供了东西的支撑,不过前几天只做了个Aop的事物,希望对大家有救助

  </aop:config>

本文由新浦京81707con发布于软件下载,转载请注明出处:澳门葡京网站最基本的理解,Spring_Aop的xml和注解

关键词: 新浦京81707con 程序开发 框架 知识点总结 软件开

上一篇:【新奥门蒲京娱乐场】发布并提供下载

下一篇:没有了