Spring学习（三）

Spring学习（三）

13.IoC注解

IoC注解：

注解：通过在类名、属性名、方法名前面加上 "@keyWord" ,从而起到和xml文件同样的作用

@Required @Autowire @PostConstrct @PreDestroy @Resource @EJB @PersistenceContext @WebServiceRef

声明使用注解形式配置：

① ， 引入 context,aop 标签

<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">

② ， 通过 context 标签声明

<!--声明使用注解配置 -->
<context:annotation-config/>
<!--声明哪个包下的类可以使用注解配置 -->
<context:component-scanbase-package="com.ioc.pojos"/>

@Component ： 写在类名之前，用来声明当前类被Spring管理，可以在小括号中指定id，如果不指定，则id默认为“当前类的类名首字母改小写”

a) 配置文件中： < context:component-scan base-package = "com.ioc.pojos" />

b) 在需要生成实例的类名前加上@Component，声明当前类被Spring管理

@Component 不指定id属性的话，默认为类名(首字母小写)

@Component ( "user01" ) 类似于 <bean id="user01" class="...User"/>

//声明User类被Spring类管理，类似于<bean id="user01" class="...User"/>
@Component("user01")
// @Component如果不指定id属性的话，默认为类名(首字母小写)
publicclass User implements Serializable {
}

@Autowired ： 自动装配，可以写在任意方法前面或者属性前面，但是不提倡写在属性前面，默认的类型匹配(autowire=byType)

写在属性前

publicclass User implements Serializable {
privateintuserId;
private String userName;
private String userPass;
//设置自动装配
@Autowired
//Group需要声明被Spring管理
private Group group;
}

写在方法前

@Autowired
publicvoid setGroup(Group group) {
this.group = group;
}

设置自动装配类型为byName

@Autowired
publicvoid setGroup(@Qualifier(value = "group") Group group) {
this.group = group;
}

@Qualifier(value = "group") : 可以指定将哪一个 bean 注入到当前属性 ( 详单与 autowire=byName)

@Autowired
publicvoid setUserDAO(@Qualifier(value = "userDAO1") UserDAO userDAO) {
this.group = group;
}

@Required ：表示当前字段必须注入，用于容错

@Scope ：在类名前加上 @Scope ( "prototype" ) 可以用来指定当前类的实例的作用域

@Autowired
publicvoid setUserDAO(@Qualifier(value = "userDAO1") UserDAO userDAO) {
this.group = group;
}

@PostConstruct ：声明初始化方式

@PostConstruct
publicvoid init() {
}

@PreDestroy ：声明销毁方法

@PreDestroy
publicvoid destroy() {
}

示例：

applicationContext.xml

<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<!--声明使用注解形式配置： ①，引入context标签 ②，通过context标签声明 -->
<!--声明使用注解配置 -->
<context:annotation-config/>
<!--声明哪个包下的类可以使用注解配置 -->
<context:component-scanbase-package="com.ioc.pojos"/>
</beans>

Group.java

package com.ioc.pojos;
import java.io.Serializable;
import org.springframework.stereotype.Component;
@Component("g")
publicclass Group implements Serializable {
privateintgroupId;
private String groupName;
public Group() {
super();
}
public Group(int groupId, String groupName) {
super();
this.groupId = groupId;
this.groupName = groupName;
}
publicint getGroupId() {
returngroupId;
}
publicvoid setGroupId(int groupId) {
this.groupId = groupId;
}
public String getGroupName() {
returngroupName;
}
publicvoid setGroupName(String groupName) {
this.groupName = groupName;
}
}

User.java

package com.ioc.pojos;
import java.io.Serializable;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
//声明User类被Spring类管理，类似于<bean id="user01" class="...User"/>
@Component("user01")
// @Component如果不指定id属性的话，默认为类名(首字母小写)
@Scope("singleton")
publicclass User implements Serializable {
privateintuserId;
private String userName;
private String userPass;
//设置自动装配
@Autowired
// Group需要声明被Spring管理
private Group group;
publicint getUserId() {
returnuserId;
}
publicvoid setUserId(int userId) {
this.userId = userId;
}
public String getUserName() {
returnuserName;
}
publicvoid setUserName(String userName) {
this.userName = userName;
}
public String getUserPass() {
returnuserPass;
}
publicvoid setUserPass(String userPass) {
this.userPass = userPass;
}
public Group getGroup() {
returngroup;
}
@Autowired
publicvoid setGroup(@Qualifier(value = "g") Group group) {
this.group = group;
}
//声明初始化方式
@PostConstruct
publicvoid init() {
}
//声明销毁方法
@PreDestroy
publicvoid destroy() {
}
}

 

14.Spring-AOP

Spring-AOP ：Aspect Oriented Programming（面向切面编程）

为什么要使用AOP？

当我们需要对原有的代码操作前后添加业务逻辑，但是又不能对源代码进行修改，我们就需要使用AOP。

AOP可以做什么？

在 不修改原有的代码 的前提下，可以在原有的某个方法的前面或者后面添加需要的业务逻辑。

面向切面的思想：在不修改原有的代码工作流的前提下，在原有的工作流中添加指定的业务逻辑。

在切面类中定义切点，通过配置文件定义连接点，再通过“通知”告诉Spring切点和切入点的对应关系。

15.Spring_AOP的xml配置

<1>， 在项目中引入jar包

*核心jar包： spring.jar
*日志jar包： commons-logging-1.0.4.jar
*dom4j包： dom4j-1.6.1.jar jaxen-1.1-beta-7.jar
*切面jar包：aspectjrt.jar aspectjweaver.jar
*cglib包：cglib-2.1.3.jar

<2>， 创建applicationContext.xml配置文件

要额外引入context标签和aop标签

<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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/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的使用

在不修改UserDAO中代码的前提下，通过Spring的AOP实现在UserDAO中delete方法前面开启事务，后面提交事务

<1>， 创建切面类

<2>， 在切面类中定义需要的切点方法

package com.aop.dao;
publicclass MyAspect {
publicvoid begin() {
System.out.println("开启事务");
}
publicvoid end() {
System.out.println("提交事务");
}
}

<3>， 在配置文件中进行配置：

a) 配置切面类，切面类需要被Spring管理

b) 在aop-config标签中进行连接点定义

c) 在aop:config标签中通过aop:aspect标签来声明切点方法和连接点的关系

示例：

UserDAO.java

package com.aop.dao;
publicclass UserDAO {
publicvoid insert() {
System.out.println("添加用户信息");
}
publicvoid delete() {
System.out.println("删除用户信息");
}
publicvoid update() {
System.out.println("更新用户信息");
}
}

MyAspect.java

package com.aop.dao;
publicclass MyAspect {
publicvoid begin() {
System.out.println("开启事务");
}
publicvoid end() {
System.out.println("提交事务");
}
}

applicationContext.xml

<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"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/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">
<beanid="udao"class="com.aop.dao.UserDAO"/>
<beanid="myAspect"class="com.aop.dao.MyAspect"/>
<aop:config>
<!--将UserDAO中的delete方法定义成连接点 -->
<!-- <aop:pointcut id="user_delete" expression="execution(public void com.aop.dao.UserDAO.delete())"
/> -->
<!--也可以使用通配符,对一个类中所有的方法都定义成连接点 -->
<!-- <aop:pointcut id="allMethod" expression="execution(public void com.aop.dao.UserDAO.*())"
/> -->
<!--通过通配符，定义一个包中所有类的所有方法都定义成连接点 -->
<aop:pointcutid="all"
expression="execution(public * com.aop.dao.*.*(..))"/>
<!--通过通配符，定义所有包中所有类的所有方法都定义成连接点 -->
<!-- <aop:pointcut id="allall" expression="execution(public * *(..))" /> -->
<aop:aspectid="test"ref="myAspect">
<!-- <aop:before method="begin" pointcut-ref="user_delete" /> <aop:after
method="end" pointcut-ref="user_delete" /> -->
<aop:beforemethod="begin"pointcut-ref="all"/>
</aop:aspect>
</aop:config>
</beans>

 

16.Spring_ AOP注解配置

<1>， 引入context,aop标签

<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"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/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>

<2>， 通过context,aop标签声明

<!--声明当前项目使用注解方式配置 -->
<context:annotation-config/>
<!--声明哪个包中的类可以使用注解形式配置 -->
<context:component-scanbase-package="com.aop.dao"/>
<!--声明使用注解形式来进行AOP注解配置 -->
<aop:aspectj-autoproxy/>

<3>， 定义切面类

package com.aop.dao;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component
//声明当前类被Spring管理
@Aspect
//声明当前类为切面类
publicclass MyAspect {
//通过注解配置连接点
//等价于<aop:pointcut id="user_delete"
// expression="execution(public void com.aop.dao.UserDAO.delete())" />
@Pointcut("execution(public void com.aop.dao.UserDAO.delete())")
publicvoid user_delete() {
}
//等价于<aop:before method="begin" pointcut-ref="user_delete" />
@Before(value = "user_delete()")
//或者@Before("execution(public void com.aop.dao.UserDAO.delete())")
publicvoid before() {
System.out.println("~~~~before~~~~");
}
//等价@After method="after" pointcut-ref="user_delete" />
@After(value = "user_delete()")
publicvoid after() {
System.out.println("~~~~after~~~~");
}
@Around(value = "user_delete()")
//参数、返回值固定写法
public Object around(ProceedingJoinPoint point) throws Throwable {
//在连接点之前执行的代码
System.out.println("before");
Object o = point.proceed();
//在连接点之后执行的代码
System.out.println("after");
return o;
}
}

注： @Around 的优先级低于 @Before 和 @After

 

17.Spring的IoC对Hibernate的支持

Spring的IoC对Hibernate的支持

可以通过Spring-IoC创建SessionFactory对象并且赋值给DAO类中的sessionFactory属性，当我面在DAO中进行增删查改的时候，可以直接使用sessionFacory属性（无需再去SessionFactory）

方法一：

<!--借助于Spring容器创建SessionFactory对象 -->
<!--classpath:表示src目录 -->
<beanid="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<propertyname="configLocation"value="classpath:hibernate.cfg.xml"></property>
</bean>
<!--将依赖Spring IoC容器创建SessionFactory对象赋值给 DAO中的sessionFactory属性 -->
<beanid="udao"class="com.hibernate.dao.UserDAO">
<propertyname="sessionFactory"ref="sessionFactory"/>
</bean>

方法二：

<beanid="myDataSource"class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">
<propertyname="driverClassName"value="oracle.jdbc.driver.OracleDriver"/>
<propertyname="url"value="jdbc:oracle:thin:@127.0.0.1:1521:orcl"/>
<propertyname="username"value="scott"/>
<propertyname="password"value="admin321"/>
<!--连接池启动时的初始值 -->
<propertyname="initialSize"value="3"/>
<!--连接池的最大值 -->
<propertyname="maxActive"value="500"/>
<!--最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
<propertyname="maxIdle"value="2"/>
<!--最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
<propertyname="minIdle"value="1"/>
</bean>
<beanid="mySessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<propertyname="dataSource"ref="myDataSource"/>
<propertyname="mappingResources">
<list>
<value>com/hibernate/pojos/User.hbm.xml</value>
</list>
</property>
<propertyname="hibernateProperties">
<value>
hibernate.dialect=org.hibernate.dialect.Oracle9Dialect
hibernate.hbm2ddl.auto=update
hibernate.show_sql=true
hibernate.format_sql=true
</value>
</property>
</bean>
<!--将依赖Spring IoC容器创建SessionFactory对象赋值给 DAO中的sessionFactory属性 -->
<beanid="udao"class="com.hibernate.dao.UserDAO">
<propertyname="MySessionFactory"ref="sessionFactory"/>
</bean>

UserDAO.java

package com.hibernate.dao;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import com.hibernate.pojos.User;
publicclass UserDAO {
private SessionFactory sessionFactory;
publicvoid insert(User user) {
Session session =sessionFactory.openSession();
session.beginTransaction();
session.save(user);
session.getTransaction().commit();
}
publicvoid delete(User user) {
Session session =sessionFactory.openSession();
session.beginTransaction();
session.delete(user);
session.getTransaction().commit();
}
publicvoid update(User user) {
Session session =sessionFactory.openSession();
session.beginTransaction();
session.update(user);
session.getTransaction().commit();
}
public SessionFactory getSessionFactory() {
returnsessionFactory;
}
publicvoid setSessionFactory(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
}

 

18.SessionFactory的创建

SessionFactory的创建

可以通过Spring-IoC创建SessionFactory对象并且赋值给DAO类中的sessionFactory属性，当我面在DAO中进行增删查改的时候，可以直接使用sessionFacory属性（无需再去SessionFactory）

步骤：

<1>导入jar文件

<2>在src下创建

<3>在src下配置，让Spring容器帮助DAO创建SessionFactory对象

[3.1]连接数据库的基本信息：

<beanid="myDataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource"
       destroy-method="close">
       <!--设置连接数据库的驱动 -->
       <propertyname="driverClass"value="oracle.jdbc.driver.OracleDriver"/>
       <!--设置连接数据库URL -->
       <propertyname="jdbcUrl"value="jdbc:oracle:thin:@127.0.0.1:1521:orcl"/>
       <!--设置用户名 -->
       <propertyname="user"value="scott"/>
       <!--设置连接的密码 -->
       <propertyname="password"value="scott"/>
       <!--设置连接数据库连接池的最大连接数 -->
       <propertyname="maxPoolSize"value="50"/>
       <!--设置连接数据库连接池的最小连接数 -->
       <propertyname="minPoolSize"value="1"/>
       <!--设置数据库连接池的最大空闲时间 -->
       <propertyname="maxIdleTime"value="20"/>
       <!--初始连接数 -->
       <propertyname="initialPoolSize"value="1"/>
   </bean>

[3.2]LocalSessionFactoryBean 对象

<4>新建DAO,在DAO配置一个属性（SessionFactory），并提供get和set方法

<5>在applicationContext文件中配置DAO

   <!--让spring容器管理  StudentDAO -->
   <beanid="studao"class="com.jjx.dao.StudentDAO">
      <propertyname="sessionFactory"ref="factory"></property>
   </bean>