spring 基本操作总结主要是aop以及依赖注入的基本配置

一所需架包

spring

commom-logging.jar  spring.jar

注解

common-annotation.jar

aop面向切面

aspectjrt.jar    aspectjweaver.jar  cglibb-nodep.ja(权限带代理proxy)

jdbc database

common-pool.1.6.jar common-dbhp.jar mysql-connector-bin-*.*.*.jar

配置文件的模板beans.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"

xmlns:tx="http://www.springframework.org/schema/tx"

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-2.5.xsd

http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd

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

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

</beans>

以上模板引入了面向切面(aop),权限代理(context)以及数据库操作(tx)的命名空间

三基本使用

1.创建bean对象

1.1默认通过set

<bean id="persionBean" class="com.my.PersionBean.impl.PersionBean" destroy-method="destory" lazy-init="true" init-method="init"></bean>

1.2通过静态工厂(factory-method)

<bean id="persionBean2" class="com.my.PersionBean.impl.PersionBeanFactory" lazy-init="true" factory-method="creBeanFactory"></bean>

1.3通过工厂非静态

<bean id="persionBean3" class="com.my.PersionBean.impl.PersionFactory" ></bean>

<bean id="persionBean4" factory-bean="persionBean3" scope="prototype" factory-method="createOrderFactory"></bean>

2.注入bean

<property name="persion" ref="persionBean4" ></property>

3.注入其他属性

<property name="name" value="校长"></property>

<property name="age" value="15"></property>

<property name="habits">

4.注入List<>属性

<property name="habits">

<list>

<value>第一个</value>

<value>第二个</value>

<value>第三个</value>

</list>

</property>

5.通过<constructor-arg index="0" value="xiaozhang"></constructor-arg>(构造函数index参数索引)

6.对象的创建scope

scope="prototype" 实体模式(多个对象)

scope="singleton"单例模式(default)在容器只有一个对象

另外还有session,request 域

通过注解方式注入

<context:annotation-config/>//开启注解

通过@Resource(name="student")指定bean的id注入 通过@[email protected](value="student")(命名id)注入

通过注解方式创建bean

@Component (任何)

@Repository(value="student")(数据访问)

@Controller(控制)

@Service(服务)

. @Scope("prototype")(指定域)

@PostConstruct(初始化方法)

@PreDestroy(销毁方法)

7.aop切面

使用jdk进行权限代理

必须有接口

@Aspect

public class MyIntercepter {

@Pointcut("execution (* com.my.aop.impl.PersionServiceBean.*(..))")

private void anyMethod() {//声明切入点

}

@Before("anyMethod()&&args(name)")

private void doAccessCheck(String name){

System.out.println("这是前置通知");

}

@AfterReturning(pointcut="anyMethod()",returning="result")

private String doAfterReturn(String result){

System.out.println("这是后置通知"+result);

return result;

}

@AfterThrowing("anyMethod()")

private void doAfterThrow(){

System.out.println("这是例外通知");

}

@After("anyMethod()")

private void doAfter(){

System.out.println("这是最终通知");

}

@Around("anyMethod()")

public Object around(ProceedingJoinPoint point) throws Throwable{

System.out.println("这是环绕通知");

Object resultObject=point.proceed();

System.out.println("推出");

return resultObject;

}

使用cglib注解方式  <aop:aspectj-autoproxy/>(启动注解)

public class MyIntercepter {

@Pointcut("execution (* com.my.aop.impl.PersionServiceBean.*(..))")

private void anyMethod() {//声明切入点

}

@Before("anyMethod()&&args(name)")

private void doAccessCheck(String name){

System.out.println("这是前置通知");

}

@AfterReturning(pointcut="anyMethod()",returning="result")

private String doAfterReturn(String result){

System.out.println("这是后置通知"+result);

return result;

}

@AfterThrowing("anyMethod()")

private void doAfterThrow(){

System.out.println("这是例外通知");

}

@After("anyMethod()")

private void doAfter(){

System.out.println("这是最终通知");

}

@Around("anyMethod()")

public Object around(ProceedingJoinPoint point) throws Throwable{

System.out.println("这是环绕通知");

Object resultObject=point.proceed();

System.out.println("推出");

return resultObject;

}

}

使用xml

<aop:aspectj-autoproxy/>

<bean id="persionServiceBean" class="com.my.aop.impl.PersionServiceBean"></bean>

<bean id="interceptor" class="com.my.aop.impl.myInterceptor"> </bean>

<aop:config>

<aop:aspect id="aspect" ref="interceptor">

<aop:pointcut expression="execution (* com.my.aop.impl.PersionServiceBean.*(..))" id="mycut"/>

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

<aop:around method="around" pointcut-ref="mycut"/>

</aop:aspect>

</aop:config>

spring对jdbc操作

<context:property-placeholder location="classpath:jdbc.properties"/>(引入属性文件)

(创建dataSource)  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

<property name="driverClassName" value="${driverClassName}"></property>

<property name="url" value="${url}"></property>

<property name="username" value="${username}"></property>

<property name="password" value="${password}"></property>

<property name="maxActive" value="${maxActive}"></property>

<property name="initialSize" value="${initialSize}"></property>

<property name="maxIdle" value="${maxIdle}"></property>

<property name="minIdle" value="${minIdle}"></property>

</bean>

<bean  id="txManager" (创建事物bean)class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<property name="dataSource" ref="dataSource"></property>

</bean>

以注解方式

<tx:annotation-driven transaction-manager="txManager" />(启动注解)

以xml

<aop:config>

<aop:pointcut expression="execution(* com.my.jdbc.service.impl.StudentService.*(..))" id="transactionPointCut"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointCut"/>

</aop:config>

<tx:advice id="txAdvice" transaction-manager="txManager">

<tx:attributes>

<tx:method name="get*" propagation="NOT_SUPPORTED"/>

<tx:method name="*" />

</tx:attributes>

</tx:advice>

详细见例子

时间: 2024-12-17 04:26:14

spring 基本操作总结主要是aop以及依赖注入的基本配置的相关文章

Spring IOC源代码具体解释之容器依赖注入

Spring IOC源代码具体解释之容器依赖注入 上一篇博客中介绍了IOC容器的初始化.通过源代码分析大致了解了IOC容器初始化的一些知识.先简单回想下上篇的内容 加载bean定义文件的过程.这个过程是通过BeanDefinitionReader来完毕的.当中通过 loadBeanDefinition()来对定义文件进行解析和依据Spring定义的bean规则进行处理 - 其实和Spring定义的bean规则相关的处理是在BeanDefinitionParserDelegate中完毕的,完毕这个

Spring详解(三)------DI依赖注入

上一篇博客我们主要讲解了IOC控制反转,也就是说IOC 让程序员不在关注怎么去创建对象,而是关注与对象创建之后的操作,把对象的创建.初始化.销毁等工作交给spring容器来做.那么创建对象的时候,有可能依赖于其他的对象,即类的属性如何赋值?这也是我们这篇博客讲解 Spring 另一个核心要点:DI依赖注入. PS:本篇博客源码下载链接:http://pan.baidu.com/s/1c2xVUDi密码:v1h3 1.什么是DI依赖注入? spring动态的向某个对象提供它所需要的其他对象.这一点

类比Spring框架来实现OC中的依赖注入

如果你之前使用过JavaEE开发中的Spring框架的话,那么你一定对依赖注入并不陌生.依赖注入(DI: Dependency Injection)是控制反转(IoC: Inversion of Control)的实现方式之一,另外一种是依赖查找(DL: Dependency Lookup).当然在Spring框架中主要使用到了控制反转中的依赖注入这种方式.当然在Spring框架中除了依赖注入外,还有一个重要的概念那就是面向切面编程(AOP). 简单的说,依赖注入负责往类中注入依赖对象,而面向切

Spring控制反转(IOC)和依赖注入(DI),再记不住就去出家!

每次看完spring的东西感觉都理解了,但是过了一段时间就忘,可能是不常用吧,也是没理解好,这次记下来. 拿ssh框架中的action,service,dao这三层举例: 控制反转:完成一个更新用户信息的业务操作,首先在action中需要service对象来处理逻辑操作,但是在action中我们并没有进行类似new Service()的操作,因为spring容器已经帮我们完成了这 样的创建被调用者对象的工作,因此称为控制翻转.这样命名这个技术可能还是有点晦涩,参考 http://blog.csd

Spring学习总结(1.2)-依赖注入及配置了解

前面的博客大概的讲了一下IOC容器的理解,那么IOC的实现实际上依托于依赖注入的.简单的说就是IOC是一种思想,而依赖注入为这种思想提供了实现.个人是这么理解的.本篇博客介绍两种常用的注入方式,以及他们的配置(基于XML). IOC容器说明 从最近的学习来看,特别是基于XML的配置形式下.IOC容器就是一个生产线,它依据配置中类之间的持有关系,一个部件一个部件的组装成一个完整的产品去执行一个完整的任务.从使用者的方向上看,他只能看到一个入口,而之后的处理他是不知道的.当然,这在没有容器的概念的时

spring学习总结一----控制反转与依赖注入

spring作为java EE中使用最为广泛的框架,它的设计体现了很多设计模式中经典的原则和思想,所以,该框架的各种实现方法非常值得我们去研究,下面先对spring中最为重要的思想之一----控制反转(依赖注入)进行简单的总结. 一.控制反转与依赖注入的概念 在学习spring框架的时候,我们习惯性地将控制反转和依赖注入放在一起,其实,两者体现的思想原则都是差不多的,只不过控制反转是一种更广泛的程序操作理念,而依赖注入是一种更为具体的实现方法,总的来说,控制反转可以依靠依赖注入来实现. 1.控制

spring中的控制反转IoC和依赖注入DI

原文:http://blog.163.com/[email protected]/blog/static/50639037200721345218382/ IoC(Inversion of Control),这是spring的核心,贯穿始终.所谓IoC,对于spring框架来说,就是由spring来负责控制对象的生命周期和对象间的关 系.这是什么意思呢,举个简单的例子,我们是如何找女朋友的?常见的情况是,我们到处去看哪里有长得漂亮身材又好的mm,然后打听她们的兴趣爱好.qq 号.电话号.手机号.

spring的容器(控制反转、依赖注入)

一.spring的容器 ”容器“是spring的一个重要概念,其主要作用是完成创建成员变量,并完成装配. 而容器的特点”控制反转“和”依赖注入“是两个相辅相成的概念. 控制反转:我们在使用一个类型的实例实现某个功能时,需要先new出该类型的一个实例,并赋值给我们声明的某个引用变量,这样我们才能够使用该变量进行操作.而new和赋值本事我们自己的权限,此处便是将该控制权限反转交给了spring. 依赖注入:某个类型要完成一个功能往往需要其他类型的变量来完成,我们在程序中往往通过自己new的方式来完成

Spring依赖注入的简化配置

一, 很久很久以前, 当我们不用@Autowire注解时, 依赖注入要么通过setter方法, 要么通过构造方法; 需要在配置文件里配置一大堆property-ref.......... 二, 若使用注解, 则造成代码的侵入性较强, 后期改起来也很蛋疼; 三, 怎么办? ----->  用default-autowire!! 废话不多说, 直接上代码: 1, 配置文件: 1 <beans xmlns="http://www.springframework.org/schema/bea