`
aaagu1234
  • 浏览: 148849 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Spring中IOC(反转控制) 和 AOP(面向方面编程)

阅读更多
一、IOC
基本注入和集合注入

实体类Bean--配置文件(applicationContext)--测试类(Test)

1.1 实体Bean:属性+getter()方法+setter()方法
public class MyBean {
private String url;
private String name;
private String pwd;
private int age;
private List list;
private Set set;
private Map map;
private Properties prop;
public String getUrl() {
    return url;
}
public void setUrl(String url) {
    this.url = url;
}

//----此处省略其他属性的getter()和setter()方法----

1.2 Spring配置文件: applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<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-3.0.xsd">
    <bean id="myBean" class="tarena.MyIoc.MyBean">
        <property name="url">
            <value>www.163.com</value>
        </property>
        <property name="name">
            <value>xuliang</value>
        </property>
        <property name="pwd" value="123456"></property>
        <property name="age">
            <value>25</value>
        </property>
        <property name="list">
            <list>
                <value>ibm</value>
                <value>sun</value>
                <value>oracle</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>music</value>
                <value>sleeping</value>
                <value>sports</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="mySister" value="yanmei"></entry>
                <entry key="myMother" value="wenxian"></entry>
                <entry key="myFather" value="guoxian"></entry>
            </map>
        </property>
    </bean>
</beans>


1.3 Test类:用于通过  ApplicationContext的方法getBean(..)获取myBean的属性值。
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "tarena/MyIoc/applicationContext.xml");
        MyBean myBean = (MyBean) ctx.getBean("myBean");
        System.out.println(myBean.getUrl());
        System.out.println(myBean.getName());
        System.out.println(myBean.getPwd());
        System.out.println(myBean.getAge());
        System.out.println(myBean.getList());
        System.out.println(myBean.getSet());
        System.out.println(myBean.getMap());
        System.out.println();
    }
}


---------------------------运行结果-----------------------------
www.163.com
xuliang
123456
25
[ibm, sun, oracle]
[music, sleeping, sports]
{mySister=yanmei, myMother=wenxian, myFather=guoxian}
---------------------------------------------------------------------

二、AOP(面向方面编程)
Aspect Oriented Programming
目标对象(TargetObject)和切面(TransactionAspect)--配置文件(applicationContext)--测试类(Test)

2.1 目标对象类(TargetObject)
public class TargetObject {
  public void add(){
     System.out.println("我添加了一些东西。。。");
  }
  public void update(){
     System.out.println("我更新了一些东西。。。");
 }
}


2.2  切面(TransactionAspect)
import org.aspectj.lang.ProceedingJoinPoint;

public class TransactionAspect {
    public void beforeMethod() {
        System.out.println("对象方法开始之前的操作。。。");
    }
    public void afterMethod() {
        System.out.println("对象方法之后的操作。。。");
    }
    public Object roundMethod(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕方法上。。。");
        Object object = pjp.proceed();
        System.out.println("环绕方法下。。。。");
        return object;
    }
    public void throwMethod() {
        new RuntimeException();
        System.out.println("异常出现执行的操作。。。");
    }
    public void afterReturningMethod() {
        System.out.println("---afterReturning--的操作。。。");
    }
}


2.3  配置文件(applicationContext)
<?xml version="1.0" encoding="UTF-8"?>
<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-3.0.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
     <!-- 目标对象 -->
    <bean id="targetObject" class="tarena.myAop.TargetObject"></bean>
   <!-- 切面对象 -->
    <bean id="transactionAspect" class="tarena.myAop.TransactionAspect"></bean>
    <aop:config>
    <!-- 定义切面aspect-->
        <aop:aspect id="myAspect" ref="transactionAspect">
    <!--切入点pointcut-->
            <aop:pointcut id="transcut" expression="execution(* tarena.myAop.*.* (..))" />
 <!--定义通知--前置通知、后置通知、最终通知、环绕通知>
            <aop:before pointcut-ref="transcut" method="beforeMethod" />
            <aop:after pointcut-ref="transcut" method="afterMethod" />
            <aop:after-returning pointcut-ref="transcut"
                method="afterReturningMethod" />
            <aop:around pointcut-ref="transcut" method="roundMethod" />
        </aop:aspect>
    </aop:config>
</beans>


2.4  测试类(Test)
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AOPTest {
    public static void main(String[] args){
        ApplicationContext ctx=new ClassPathXmlApplicationContext(
                "tarena/myAop/applicationContext.xml");
        TargetObject targetObject= (TargetObject) ctx.getBean("targetObject");
        targetObject.add();
    }
}
分享到:
评论

相关推荐

    Spring中IOC(反转控 制) 和 AOP(面向方面编程)

    在Java世界里,Spring框架是应用最广泛的轻量级框架之一,它的核心特性包括IOC(Inversion of Control,反转控制)和AOP(Aspect Oriented Programming,面向方面编程)。这两个概念是Spring框架的灵魂,极大地提升...

    springioc和spring aop

    Spring框架是Java开发中不可或缺的一部分,它通过提供两种核心特性——控制反转(IoC)和面向切面编程(AOP)来简化应用的构建。理解并掌握这两种技术对于任何Java开发者来说都至关重要。 **控制反转(IoC)**,也...

    spring ioc和aop原理流程图(详细)

    Spring 框架是Java开发中的核心框架,它主要由两个关键部分组成:IOC(Inversion of Control,控制反转)和AOP(Aspect Oriented Programming,面向切面编程)。这两个概念是Spring框架的核心特性,极大地简化了企业...

    Spring IOC 控制反转

    它通过依赖注入(Dependency Injection, DI)和面向切面编程(Aspect Oriented Programming, AOP)等特性实现了对应用程序的解耦,并通过IOC(Inversion of Control)控制反转来简化配置和管理。 #### 二、Spring ...

    以注解方式模拟Spring IoC AOP

    在Spring框架中,依赖注入(Inversion of Control, IoC)和面向切面编程(Aspect Oriented Programming, AOP)是两大核心特性。本篇将深入探讨如何通过注解方式来模拟Spring的这两种机制,帮助你理解其底层原理。 #...

    Spring中IOC/AOP的说明和例子

    在Spring框架中,IOC(Inversion of Control,控制反转)和AOP(Aspect-Oriented Programming,面向切面编程)是两个核心的概念,它们极大地提高了软件开发的灵活性和可维护性。 **IOC(控制反转)**是Spring的核心...

    Spring 的IOC和AOP特点

    Spring的核心:IOC与AOP。IOC是控制反转或依赖注入,AOP是面向切面编程。

    Spring IOC AOP MVC 简单例子

    例如,`SpringIOC`目录中的配置文件(如`applicationContext.xml`)用于定义bean的定义和它们之间的依赖关系。通过XML或注解方式声明bean,Spring可以自动管理bean的实例化、初始化和销毁,从而简化了代码并提高了可...

    Spring IOC和Spring AOP_spring aop_springIOC

    Spring框架是Java开发中最常用的轻量级框架之一,它的核心特性包括依赖注入(Dependency Injection,简称DI)和面向切面编程(Aspect-Oriented Programming,简称AOP)。这两个概念是Spring框架的基石,极大地简化了...

    Spring AOP IOC源码笔记.pdf

    Spring框架是Java开发中不可或缺的一部分,它主要由两个核心组件构成:IoC(Inversion of Control,控制反转)和AOP(Aspect Oriented Programming,面向切面编程)。本笔记将深入探讨这两个概念以及它们在Spring中...

    Spring中IOC和AOP的详细解释共1页.pdf.zi

    Spring框架是Java开发中最常用的轻量级框架之一,它的核心特性包括依赖注入(Inversion of Control,简称IOC)和面向切面编程(Aspect Oriented Programming,简称AOP)。这两个概念对于理解和使用Spring框架至关...

    关于spring的AOP ,IOC,DI的理解

    Spring的核心特性包括AOP(面向切面编程)和IOC(控制反转),以及依赖注入(DI)。以下是对这些概念的详细解释: **面向切面编程(AOP)** AOP是一种编程范式,它允许开发者将关注点从主业务逻辑中分离出来,例如...

    SpringIOC和AOP实现机制模拟

    Spring框架是Java开发中不可或缺的一部分,它通过提供控制反转(IOC)和面向切面编程(AOP)等核心特性,极大地简化了企业级应用的构建。让我们深入探讨这两个概念及其在Spring中的实现机制。 首先,Spring的控制...

    myeclipse spring IOC和AOP 例子

    Spring框架是Java开发中的核心组件,它通过控制反转(IOC)和面向切面编程(AOP)等特性,极大地简化了企业级应用的构建。在本教程中,我们将深入探讨这两个概念以及如何在MyEclipse环境中使用它们。下面将详细阐述...

    Spring3.1 IOC+AOP需要的jar包

    Spring 3.1 是一个非常重要的Java框架,它在企业级应用开发中广泛使用,尤其在控制反转(IOC)和面向切面编程(AOP)方面。这些概念是Spring框架的核心特性,帮助开发者实现松耦合和代码复用,提高了应用程序的可...

    spring教程 ioc aop

    本教程围绕“Spring教程:IOC(控制反转)和AOP(面向切面编程)”展开,同时涵盖了与Hibernate的整合。 **Spring的IOC(控制反转)** 控制反转(Inversion of Control,简称IOC)是一种设计思想,它的主要目的是...

    浅谈 Spring 原理 透析,ioc aop

    浅谈 Spring 原理 透析,IOC 和 AOP Spring 框架是一个从实际项目开发经验中抽取的,可高度重用的应用框架。它是一个轻量级容器,带有包装器,使许多不同的服务和框架更易于使用。轻量级容器接受任何 JavaBean,而...

    学习Spring笔记_IoC(控制反转)简介

    在传统编程中,程序员需要手动创建和管理对象,而在IoC中,这些控制权被反转,由一个外部容器(在Spring中是ApplicationContext)负责创建、装配和管理对象,使得代码更加灵活和可测试。 ### 2. Spring中的依赖注入...

Global site tag (gtag.js) - Google Analytics