关闭

Spring 学习笔记

109人阅读 评论(0) 收藏 举报
分类:

.搭建Spring环境

1.最先下载并在Eclipse里安装Spring的插件

Springsource-tool-suite

 

2.导入最重要的5个包

Commons-logging-1.2.jar

Spring-beans-4.2.2.RELEASE.jar

Spring-context-4.2.2.RELEASE.jar

Spring-core-4.2.2.RELEASE.jar

Spring-expression-4.2.2.RELEASE.jar

 

.Spring 配置

1.新建spring XML配置文件(new > other > spring > springbean configuration file

例子:

1.1     常用bean

<beanid="HelloWorld" class="com.chenj.app.test.HelloWorld">

<propertyname="name" value="chenj"></property>

</bean>

         ref

关联其他对象

  parent

继承父类bean

abstract

true 则是抽象bean 不能被实例化

depends-on

依赖(多个bean 可以用,或空格)

autowire

byType   根据bean的类型和当前bean的属性的类型

byName 根据bean的名字和当前beansetter

scope

Bean的作用域

singleton:默认值  最初创建IOC容器时初始化对象

prototype:原型的 最初创建IOC容器时不初始化对象

每次请求时都创建一个新bean实例

init-method

指定初始化方法

destroy-method

指定销毁方法

factory-method

指向工厂方法的名字

factory-bean

装载工厂

 

 

1.2   定义集合

<util:list id="list">

<bean id="1"></bean>

<bean id="2"></bean>

</util:list>

 

1.3   导入属性文件

<context:property-placeholderlocation="classpath:db.properties"/>

直接使用${key}

 

2.可以通过以下方法加载

2.1     ApplicationContextctx = new ClassPathXmlApplicationContext("applicationContent.xml");

加载的过程做了两个操作,实例化了XML里配置的类的对象和其Set方法

 

2.2   ctx.getBean("BeanID")

获取对象

 

3.SpEL

格式

#{…}

T(类全名)

直接引用类

#{Car}

对象

#{Car.band}

对象属性

#{T(java.lang.Math).PI * 80}

 

#{1==1 ? Ture : flase}

 

 

 

4.工厂方法

4.1 静态工厂方法(直接调用工厂的方法)

Class StaticCarFactory{

Pubic static Car getCar(String name){

//…

}

}

 

<bean id="car1"class="com.chenj.app.StaticCarFactory"factory-method="getCar">

<constructor-argvalue="audi"></constructor-arg>

</bean>

 

4.2 实例工厂方法(先实例化工厂,再调用工厂的方法)

Class StaticCarFactory{

Public Car getCar(String name){

//…

}

}

 

<bean id="carFactory"class="com.chenj.app.StaticCarFactory" >

</bean>

<bean id="car2"factory-bean="carFactory" factory-method="getCar">

<constructor-argvalue="audi"></constructor-arg>

</bean>

 

5.注解

5.1 扫描注解

<context:component-scanbase-package="com.chenj.app">

<!-- 不包含哪些 -->

<context:exclude-filtertype="annotation" expression="com.chenj.app.test"/>

 

<!-- 只包含哪些 -->

<context:include-filtertype="annotation" expression="com.chenj.app.test"/>

 

</context:component-scan>

 

5.2 常用注解

@Service

业务层

@Repository

持久层

@Controller

表现层

@Component

基本注解

@Autowired

自动匹配

@Qualifiter

自动匹配有多个同样的bean时,用于指定Bean

@Aspect

切面

@Order

指定切面的优先级,越小优先级越高

@Pointcut

来声明切入点表达式

 

6.AOP

6.1 导入需要加入的架包

Com.springsource.org.aopalliance-1.0.0.jar

Com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar

Spring-aop-4.0.0.RELEASE.jar

Spring-aspects-4.0.0.RELEASE.jar

 

6.2 基于注解的方式

6.2.1

把一个类声明为一个切面:需要把该类放入到IOC容器中,再声明为切面

@Aspect

@Component

Class test{

@before("execution(public int com.chenj.app.Test.add(int ,int))")

Public void beforeMethod(JoinPoint joinPoint){

/…         joinPoint可以获取到方法的信息以及传入的参数

}

}

 

需要在XML配置里启动Aspjectbeftore..通知才会起作用

加入aop的命名空间

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

 

6.2.2 通知类型

@Before

前置通知,在方法执行之前执行

@After

后置通知,在方法执行之后执行

@AfterReturning

返回通知,在方法返回结果之后 执行

@AfterThrowing

异常通知,在方法抛出异常之后

@Around

环绕通知,围绕着方法执行

 

6.2.3 重用执行表达式

@Pointcut("execution(public intcom.chenj.app.Test.*(..))")

Public voidjoinPointExpression( ){ 空的就行 }

定义一个方法,用于声明切入点表达式,一般,该方法内不需要再加代码

@Before("joinPointExpression( )")

@After("joinPointExpression( )")

 

6.3 基于配置文件的方式

xml 和正常的bean一样加载 Aspect .

然后配置AOP

例:

<aop:config>

<!--配置切点表达式-->

<aop:pointcut expression="execution(* com.chenj.app.test.*(..))" id="pointcut"/>

<!--配置切面及通知-->

<aop:aspect ref="bean" order="2">

<aop:before method="方法名" pointcut-ref="pointcut">

<aop:after method="方法名" pointcut-ref="pointcut">

<aop:after-returning method="方法名" pointcut-ref="pointcut"returning="result">

<aop:after-throwing method="方法名" pointcut-ref="pointcut"throwing="e">

</aop:aspect>

</aop:config>

 

7.JDBCTemplate

例:配置文件

<context:property-placeholderlocation="classpath:db.properties"/>

<beanid="dataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource">

<propertyname="user" value="${jdbc.user}"></property>

<propertyname="password"value="${jdbc.password}"></property>

<propertyname="driverClass"value="${jdbc.driverClass}"></property>

<propertyname="jdbcUrl" value="${jdbc.jdbcUrl}"></property>

 

<propertyname="initialPoolSize"value="${jdbc.initPoolSize}"></property>

<propertyname="maxPoolSize"value="${jdbc.maxPoolSize}"></property>

</bean>

 

<beanid="jdbcTemplate"class="org.springframework.jdbc.core.JdbcTemplate">

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

</bean>

测试用例

privateApplicationContext        ctx=null;

privateJdbcTemplate jdbcTemplate = null;

privateEmployeeDAO employeeDAO=null;

 

{

ctx= new ClassPathXmlApplicationContext("applicationContext.xml");

jdbcTemplate=ctx.getBean(JdbcTemplate.class);

employeeDAO=ctx.getBean(EmployeeDAO.class);

}

 

//查询结果集

@Test

publicvoid queryEmployeeList(){

Stringsql="select * from employee";

RowMapper<Employee>rowMapper=new BeanPropertyRowMapper<>(Employee.class);

List<Employee>list=jdbcTemplate.query(sql, rowMapper);

System.out.println(list);

}

 

//查询单条记录

@Test

publicvoid queryEmployee(){

Stringsql="select * from employee where id=?";

RowMapper<Employee>rowMapper=new BeanPropertyRowMapper<>(Employee.class);

Employeeemployee=jdbcTemplate.queryForObject(sql, rowMapper,1);

System.out.println(employee);

}

 

//修改

@Test

publicvoid updateEmployee(){

Stringsql="update employee set name=? where id=?";

jdbcTemplate.update(sql,newObject[]{"chenj",1});

}

 

//测试链接

@Test

public  void getDataSource() throws SQLException{

DataSourcedataSource=ctx.getBean(DataSource.class);

System.out.println(dataSource.getConnection());

}

 

8.事务

8.1 注解的方式

8.1.1 在配置中声明事务管理器,用于管理数据源

例:

<bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

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

</bean>

<!-- 开启tx命名空间,启动事务注解支持-->

<tx:annotation-driventransaction-manager="transactionManager"/>

 

然后只要在需要事务管理的方法上 @Transactional

 

JDBC

Class   DataSourceTransactionManager

Hibernate

Class   HibernateTransactionManager

JTA

Class   JtaTransactionManager

 

8.1.2 事务的传播行为

一个事务方法调用另外一个事务方法

默认是REQUIRED

即使用调用方法的事务

REQUIRED_NEW

被调用方法使用自己的事务,调用方法的事务被挂起

 

@Transactional(propagation=Propagation.REQUIRED)

 

8.1.3 事务的隔离级别

1):Isolation声明事务隔离级别最常用READ_COMMITTED

2):默认情况下Spring 的声明式事务对所有运行时异常进行回滚

3):使用readOnly 指定事务是否为只读,表示这个事务只读取数据但不更新数据,这样可以帮助数据库引擎优化事务,若真的是一个只读数据库值的方法,应设置 readOnly=true

4):使用timeout 指定强制回滚之前事务可以占用的时间(例子方法执行超过3秒自动强制回滚)

例:

@Transactional(isolation=Isolation.READ_COMMITTED

readOnly=false,timeout=3)

 

8.2 XML方式

                    <!-- 1.配置事务管理器-->

<bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

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

</bean>

 

        <!-- 2.配置事务属性-->

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

<tx:attributes>

<tx:method name="方法名" propagation="REQUIRED_NEW">

<tx:method name="*">

</tx:attributes>

</tx:advice>

 

        <!-- 3.配置事务切入点,以及把事务切入点和事务属性关联起来-->

<aop:config>

<aop:pointcut expression="execution(*com.chenj.app.test.*(..))" id="txPointcut">

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

</aop:config>


0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:478次
    • 积分:81
    • 等级:
    • 排名:千里之外
    • 原创:8篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档