spring学习笔记一

spring学习笔记
一、Spring中两个十分重要的概念——IOC/DI & AOP
1.IOC/DI(Inverse of control/Dependence Injection)
IOC:控制反转，看起来比较牛B，说起来十分简单。就是不使用传统的将类的依赖关系用硬编码来维护的方式，而是让容器来管理类之间的依赖，依赖关系在全在一个配置文件上。这样，就将造成耦合的根源——复杂的依赖关系，进行了统一的，集约式管理。

DI：依赖注入，其实就是控制反转。只是比IOC的表达稍微好点，更能望文生意些。依赖注入，简单地说，就是在运行期间，由容器将组件之间的依赖关系注入到组件中。

IOC/DI的作用：有了这样的设计，我们只需要专心编写一个个高内聚的零件，而不用关心这些零件如何组合起来工作。这个问题是由依赖关系的配置文件需要关注的。这样将组件和依赖分离，提高了组件的可重用性。

三种IOC/DI方式：
1.接口注入：
  将实现类的对象赋给接口的引用。实现类的对象是通过配置文件描述，由容器负责创建的。
  注意：目前部门使用的BS，就是这种方式。
2.值注入：
  通过setxxx方法，将依赖关系注入到某个具体的对象中。Spring使用最多的依赖注入方式就是值注入。
3.构造子注入：
  容器调用实现类的购造器，将依赖作为构造器的参数注入，一次性构建一个稳定的对象。

后两种依赖注入方式的比较：
1.值注入：自然，直接，简洁，但不稳定(如果在set的时候发生并发访问，可能会出现很严重的状况)
2.构造子注入：复杂，但很稳定(一次性创建，在创建阶段就将依赖注入了，创建完成后，就已经是一个完成的，稳定的对象)，而且可以很好地控制依赖注入的顺序关系。

2.AOP(Aspect Oriented Programming)
AOP：翻译为面向方法编程，网上说比较确切的说法是面向切面编程。我个人认为，说成是面向动作编程好象更加贴切。因为AOP是将某类动作高度内聚的编程方法。

AOP的特点：1.切分动作  2.源代码无关性

AOP在Spring中的应用：事务管理机制

Spring事务管理机制的基本原理：
1.用一个动态Proxy类加载所有的配有事物管理的Bean
2.根据配置的事务触发点做if判断，然后在方法的前后加上事务处理的代码

Spring中的两种AOP方式：
1.Proxy：面向接口
2.CGLIB：面向Class

对于AOP在Spring中的应用还不是十分清楚，需要加强。

二、struts+spring+hibernate 整合
1.在Eclipse中创建项目
2.加入struts
3.加入spring
4.加入hibernate
5.整合struts&spring
  1)通过plug-in将struts与spring对接
  2)通过action的type属性将Action的控制权转给spring/
  3)spring中配置action的实现类
6.整和spring+hibernate
  1)只需要配置spring中的sessionFactory就可以了。十分方便。
  2)为数据库访问类配置spring的事务管理，使得持久层的操作可以在spring的控制范围之内。

(注意：以上内容比较简单，纯属记录个人学习过程。而且由于刚刚接触spring，水平有限。不足之处，请多多原谅)

附：登录模块示例

配置文件部分

Struts配置：struts-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN" "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">

<struts-config>
  <data-sources />
  <form-beans>
   <form-bean name="loginForm" type="com.neusoft.apps.login.rp.LoginForm"/>
  </form-beans>
  <global-exceptions />
  <global-forwards />
  <action-mappings>
   <action path="/loginAction"
    type="org.springframework.web.struts.DelegatingActionProxy"
    name="loginForm"
    scope="request"
    parameter="method">
    <forward name="ok" path="/index.jsp"></forward>
    <forward name="failed" path="/login.jsp"></forward>
   </action>
  </action-mappings>
  <message-resources parameter="com.neusoft.apps.ApplicationResources" />
  <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
   <set-property property="contextConfigLocation" value="/WEB-INF/classes/applicationContext.xml"/>
  </plug-in>
</struts-config>

 

Spring配置：applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
 <bean id="sessionFactory"
  class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
  <property name="configLocation">
   <value>/WEB-INF/classes/hibernate.cfg.xml</value>
  </property>
 </bean>
 
 <bean id="transactionManager"
  class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory">
   <ref local="sessionFactory"/>
  </property>
 </bean>
 
 <bean id="loginDAO"
  class="com.neusoft.apps.login.bp.LoginBSImp">
  <property name="sessionFactory">
   <ref local="sessionFactory"/>
  </property>
  <property name="hql">
   <value>from LOGIN login where login.aae011=? and login.aae012=?</value>
  </property>
 </bean>
 
 <bean id="loginDAOProxy"
  class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
  <property name="transactionManager">
   <ref bean="transactionManager"/>
  </property>
  
  <property name="target">
   <ref local="loginDAO"/>
  </property>
  
  <property name="transactionAttributes">
   <props>
    <prop key="insert*">PROPAGATION_REQUIRED</prop>
    <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
    <prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>
   </props>
  </property>
 </bean>
 
 <bean name="/loginAction"
  class="com.neusoft.apps.login.rp.LoginAction"
  singleton="false">
  <property name="dao">
   <ref bean="loginDAOProxy"/>
  </property>
 </bean>
 
</beans>

Hibernate配置：hibernate.cfg.xml:略，没什么好看的，就是配了个数据源

代码部分：

Action:

package com.neusoft.apps.login.rp;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DispatchAction;

import com.neusoft.apps.login.LoginBS;

public class LoginAction extends DispatchAction{
 
 private LoginBS dao;
 
 public ActionForward login(ActionMapping actionMapping,
   ActionForm actionForm,
   HttpServletRequest request,
   HttpServletResponse response) throws Exception {
  // TODO Auto-generated method stub
  LoginForm form = (LoginForm) actionForm;
  if(dao.isValidUser(form.getAae011(),form.getAae012()))
   return actionMapping.findForward("ok");
  else
   return actionMapping.findForward("failed");
 }

 public LoginBS getDao() {
  return dao;
 }

 public void setDao(LoginBS dao) {
  this.dao = dao;
 }
}

 

DAOImp:

package com.neusoft.apps.login.bp;

import java.util.List;

import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.neusoft.apps.login.LoginBS;

public class LoginBSImp extends HibernateDaoSupport implements LoginBS{
 private SessionFactory sessionFactory;
 
 private String hql;
 
 public boolean isValidUser(String username, String password) {
  // TODO Auto-generated method stub
  List userList = this.getHibernateTemplate().find(hql, new Object[]{username,password});
  if(userList.size() > 0)
   return true;
  else
   return false;
 }

 public String getHql() {
  return hql;
 }

 public void setHql(String hql) {
  this.hql = hql;
 }
 
 
}