框架简单描述总结

spring

spring 主要是IOC控制反转和AOP切面，通过web.xml dispatcherServlet配置spring,首先包扫描，之后配置bean依赖注入，IOC 利用java里的反射  反射其实就是在运行时动态的去创建、调用对象，Spring就是在运行时，跟xml Spring的配置  文件来动态的创建对象，和调用对象里的方法的 。  

容器提供了AOP技术，利用它很容易实现如权限拦截、运行期监控等功能。

spring mvc

1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。 

2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.  3.DispatcherServlet请请求提交到目标Controller  

4.Controller进行业务逻辑处理后，会返回一个ModelAndView 

5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象 

6.视图对象负责渲染返回给客户端。

Spring的事务管理：  

事务就是对一系列的数据库操作（比如插入多条数据）进行统一的提交或回滚操作，如果插入成功，那么一起成功，如果中间有一条出现异常，那么回滚之前的所有操作。

http://blog.csdn.net/xh921/article/details/48790603

http://blog.csdn.net/zuoluoboy/article/details/19766131

MVC

M是指业务模型，V是指 用户界面，C则是控制器 使用MVC的目的是将M和V的实现代码分离, C存在的目的则是确保M和V的同步

MVC 分层同时也简化了分组开发。不同的开发人员可同时开发视图、控制器逻辑和业务逻辑。

Model（模型）是应用程序中用于处理应用程序数据逻辑的部分。

　　通常模型对象负责在数据库中存取数据。

View（视图）是应用程序中处理数据显示的部分。

　　通常视图是依据模型数据创建的。

Controller（控制器）是应用程序中处理用户交互的部分。

　　通常控制器负责从视图读取数据，控制用户输入，并向模型发送数据。

Mybites

Mybatis实现了DAO接口与xml映射文件的绑定，自动为我们生成接口的具体实现，使用起来变得更加省事和方便。

 MyBatis应用程序根据XML配置文件创建SqlSessionFactory，SqlSessionFactory在根据配置，配置来源于两个地方，一处是配置文件，一处是Java代码的注解，获取一个SqlSession。SqlSession包含了执行sql所需要的所有方法，可以通过SqlSession实例直接运行映射的sql语句，完成对数据的增删改查和事务提交等，用完之后关闭SqlSession。

1.首先通过dispatcherServlet 配置spring-mybatis.xml

2.SqlSessionFactoryBean初始化把*mapper.xml的*保存成*sqlSession对象到内存，

3.MapperScannerConfigurer同时扫描包把特点注解添加到spring容器里。MyBatis在初始化的时候，会将MyBatis的配置信息全部加载到内存中，使用org.apache.ibatis.session.Configuration实例来维护。使用者可以使用sqlSession.getConfiguration()方法来获取。MyBatis的配置文件中配置信息的组织格式和内存中对象的组织格式几乎完全对应的。

加载到内存中会生成一个对应的MappedStatement对象，然后会以key="com.louis.mybatis.dao.EmployeesMapper.selectByMinSalary" ，value为MappedStatement对象的形式维护到Configuration的一个Map中。当以后需要使用的时候，只需要通过Id值来获取就可以了。

SqlSession根据Statement ID, 在mybatis配置对象Configuration中获取到对应的MappedStatement对象，然后调用mybatis执行器来执行具体的操作。

mybatis其实是JDBC的一个简单封装

常用注解

@Component 所有受Spring 管理组件的通用形式 @Component不推荐使用。

@Controller 对应表现层的Bean，也就是Action

@Scope("prototype")表示将Action的范围声明为原型， 可以利用容器的scope="prototype"来保证每一个请求有一个单独的Action来处理，避免struts中Action的线程安全问题。

@ Service 对应的是业务层Bean

@ Repository 对应数据访问层Bean

http://www.cnblogs.com/xdp-gacl/p/3495887.html

http://blog.csdn.net/luanlouis/article/details/40422941

SSH

struts 作为系统的 整体基础 架构 ，负责MVC的分离，在Struts框架的模型部分，控制业务跳转，利用Hibernate框架对持久层提供支持 。 Spring 一方面作为一个轻量级的 IoC 容器，负责查找、定位、创建和管理对象及对象之间的依赖关系，另一方面能使 Struts 和 Hibernate 更好地工作。

Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。

strut2的体系结构:

当Web容器收到请求（HttpServletRequest）它将请求传递给一个标准的的过滤链包括  流程（ActionContextCleanUp）过滤器，然后经过Other filters(SiteMesh ,etc),

接下来需要调用FilterDispatcher核心控制器，然后它调用ActionMapper确定请求那个Action，ActionMapper返回一个收集Action详细信息的ActionMaping对象。

接下来FilterDispatcher将控制权委派给ActionProxy,ActionProxy调用配置管理器(ConfigurationManager) 从配置文件中读取配置信息(struts.xml)，然后创建ActionInvocation对象，ActionInvocation在调用Action之前会依次的调用所用配置拦截器（Interceptor N） 一旦执行结果返回结果字符串ActionInvocation负责查找结果字符串对应的(Result）然后执行这个Result Result会调用一些模版（JSP）

来呈现页面，之后拦截器(Interceptor N)会在被执行(顺序和Action执行之前相反)最后响应(HttpServletResponse)被返回在web.xml中配置的那些过滤器和（核心控制器）（FilterDispatcher）。

Hibernate

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。

为什么使用Hibernate？

1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

2 、Hibernate是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作，将软件开发人员从大量相同的数据持久层相关编程工作中解放出来，使开发更对象化了。

3 、移植性好，支持各种数据库，如果换个数据库只要在配置文件中变换配置就可以了，不用改变hibernate代码。

4 、支持透明持久化，因为hibernate操作的是纯粹的（pojo）java类，没有实现任何接口，没有侵入性。所以说它是一个轻量级框架。

http://www.open-open.com/lib/view/open1413527015465.html#articleHeader2

一个类实现了 Serializable接口 ，那么这个类可以被序列化和反序列化。不用实现任何特定的方法，只需要在声明类的时候加上implements java.io.Serializable即可。

通过filter 初始化配置struts2， context-param listener初始化spring(applicationContext),这样

通过请求路径进入struts2，在通过spring注入到函数内

public class MgrmenuServiceImpl extends ActionSupport

配置和代码：

<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>

<context-param>
<!-- 参数名固定 -->
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext-*.xml</param-value>
</context-param>

<listener>
<!-- 这个监听器会去加载全局上下文参数名为：contextConfigLocation所指定的所有配置文件 -->
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

strut2

<action name="Login" class="Login" method="Login">
<result name="success" type="chain">WebIndex</result>
<result name="error">/BcakMain/view/Login.jsp</result>
</action>

spring

<bean id="Login" class="com.htm.actions.UsersServiceImpl">
<property name="usersdao" ref="UsersDAO"/>
</bean>

controller

public String Login() {
// TODO Auto-generated method stub
HttpServletRequest request = ServletActionContext.getRequest();
HttpSession session = request.getSession();
String rands = (String) session.getAttribute("rands");
if(rands.equals(getVcode())){
Users modelus = new Users();
modelus.setUsersname(this.getUsersname());
modelus.setPassword(this.getPassword());
if(usersdao.findByExample(modelus).isEmpty()){
this.setErrorMeg("账号密码错误！");
return ERROR; 
}else{ 
//获取用户名 
session.setAttribute("usersname", this.getUsersname());
//获取权限
String thql = "from Users where usersname="+this.getUsersname();
uls=this.usersdao.getHibernateTemplate().find(thql);
int permit=uls.get(0).getPermit();
session.setAttribute("permit", permit);
System.out.println("sdsd");
return SUCCESS;
}
}
this.setErrorMeg("验证码错误！");
return ERROR; 
}

hibernate-mapping

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 
Mapping file autogenerated by MyEclipse Persistence Tools
-->
<hibernate-mapping>
<class name="com.htm.daos.MgrmenuDao.Mgrmenu" table="mgrmenu" catalog="htmhelper">
<id name="id" type="java.lang.Integer">
<column name="id" />
<generator class="native"></generator>
</id>
<property name="mgrpid" type="java.lang.Integer">
<column name="mgrpid" />
</property>
<property name="mgrname" type="java.lang.String">
<column name="mgrname" length="100" />
</property>
<property name="mgrlinkurl" type="java.lang.String">
<column name="mgrlinkurl" length="100" />
</property>
<property name="mgrtwo" type="java.lang.Integer">
<column name="mgrtwo" />
</property>
<property name="permit" type="java.lang.Integer">
<column name="permit" />
</property>
<property name="dtop" type="java.lang.Integer">
<column name="dtop" />
</property>
<property name="sort" type="java.lang.Integer">
<column name="sort" />
</property>
<property name="site" type="java.lang.String">
<column name="site" length="100" />
</property>
</class>
</hibernate-mapping>

package com.htm.daos.MgrmenuDao;

import java.sql.SQLException;
import java.util.List;

import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.Query;
import org.hibernate.Session;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

/**
* A data access object (DAO) providing persistence and search support for
* Mgrmenu entities. Transaction control of the save(), update() and delete()
* operations can directly support Spring container-managed transactions or they
* can be augmented to handle user-managed Spring transactions. Each of these
* methods provides additional information for how to configure it for the
* desired type of transaction control.
* 
* @see com.htm.daos.MgrmenuDao.Mgrmenu
* @author MyEclipse Persistence Tools
*/
public class MgrmenuDAO extends HibernateDaoSupport {
private static final Logger log = LoggerFactory.getLogger(MgrmenuDAO.class);
// property constants
public static final String MGRPID = "mgrpid";
public static final String MGRNAME = "mgrname";
public static final String MGRLINKURL = "mgrlinkurl";
public static final String MGRTWO = "mgrtwo";
public static final String PERMIT = "permit";
public static final String DTOP = "dtop";
public static final String SORT = "sort";
public static final String SITE = "site";

protected void initDao() {
// do nothing
}

public void save(Mgrmenu transientInstance) {
log.debug("saving Mgrmenu instance");
try {
getHibernateTemplate().save(transientInstance);
log.debug("save successful");
} catch (RuntimeException re) {
log.error("save failed", re);
throw re;
}
}

public void delete(Mgrmenu persistentInstance) {
log.debug("deleting Mgrmenu instance");
try {
getHibernateTemplate().delete(persistentInstance);
log.debug("delete successful");
} catch (RuntimeException re) {
log.error("delete failed", re);
throw re;
}
}

public Mgrmenu findById(java.lang.Integer id) {
log.debug("getting Mgrmenu instance with id: " + id);
try {
Mgrmenu instance = (Mgrmenu) getHibernateTemplate().get(
"com.ados.MgrmenuDAO.Mgrmenu", id);
return instance;
} catch (RuntimeException re) {
log.error("get failed", re);
throw re;
}
}

public List findByExample(Mgrmenu instance) {
log.debug("finding Mgrmenu instance by example");
try {
List results = getHibernateTemplate().findByExample(instance);
log.debug("find by example successful, result size: "
+ results.size());
return results;
} catch (RuntimeException re) {
log.error("find by example failed", re);
throw re;
}
}

public List findByProperty(String propertyName, Object value) {
log.debug("finding Mgrmenu instance with property: " + propertyName
+ ", value: " + value);
try {
String queryString = "from Mgrmenu as model where model."
+ propertyName + "= ?";
return getHibernateTemplate().find(queryString, value);
} catch (RuntimeException re) {
log.error("find by property name failed", re);
throw re;
}
}

public List findByMgrpid(Object mgrpid) {
return findByProperty(MGRPID, mgrpid);
}

public List findByMgrname(Object mgrname) {
return findByProperty(MGRNAME, mgrname);
}

public List findByMgrlinkurl(Object mgrlinkurl) {
return findByProperty(MGRLINKURL, mgrlinkurl);
}

public List findByMgrtwo(Object mgrtwo) {
return findByProperty(MGRTWO, mgrtwo);
}

public List findByPermit(Object permit) {
return findByProperty(PERMIT, permit);
}

public List findByDtop(Object dtop) {
return findByProperty(DTOP, dtop);
}

public List findBySort(Object sort) {
return findByProperty(SORT, sort);
}

public List findBySite(Object site) {
return findByProperty(SITE, site);
}

public List findAll() {
log.debug("finding all Mgrmenu instances");
try {
String queryString = "from Mgrmenu";
return getHibernateTemplate().find(queryString);
} catch (RuntimeException re) {
log.error("find all failed", re);
throw re;
}
}
public Mgrmenu merge(Mgrmenu detachedInstance) {
log.debug("merging Mgrmenu instance");
try {
Mgrmenu result = (Mgrmenu) getHibernateTemplate().merge(
detachedInstance);
log.debug("merge successful");
return result;
} catch (RuntimeException re) {
log.error("merge failed", re);
throw re;
}
}

public void attachDirty(Mgrmenu instance) {
log.debug("attaching dirty Mgrmenu instance");
try {
getHibernateTemplate().saveOrUpdate(instance);
log.debug("attach successful");
} catch (RuntimeException re) {
log.error("attach failed", re);
throw re;
}
}

public void attachClean(Mgrmenu instance) {
log.debug("attaching clean Mgrmenu instance");
try {
getHibernateTemplate().lock(instance, LockMode.NONE);
log.debug("attach successful");
} catch (RuntimeException re) {
log.error("attach failed", re);
throw re;
}
}

public static MgrmenuDAO getFromApplicationContext(ApplicationContext ctx) {
return (MgrmenuDAO) ctx.getBean("MgrmenuDAO");
}
public int getAllRowCount(String hql) {
log.debug("finding all Mgrmenu instances");
try {
String queryString = hql; //"from Mgrmenu";
return getHibernateTemplate().find(queryString).size();
} catch (RuntimeException re) {
log.error("find all failed", re);
throw re;
}
}

@SuppressWarnings("unchecked")
public List queryForPage(final String hql,final int offset,final int length) {
// TODO Auto-generated method stub
List list =null;
try {
list = (List)getHibernateTemplate().execute(new HibernateCallback(){
public Object doInHibernate(Session session) throws HibernateException, SQLException {
String queryString =hql; //"from Mgrmenu";
Query query = session.createQuery(queryString);
query.setFirstResult(offset);
query.setMaxResults(length);
return query.list();
}
});
} catch (RuntimeException re) {
log.error("find all failed", re);
throw re;
}
return list;
}
}

package com.gacx.dao.impl;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.stereotype.Repository;
import com.gacx.dao.daointer.GeneralDao;

@Repository
public class GeneralDaoImpl implements GeneralDao {

@Autowired
private JdbcTemplate jdbcTemplate;

@Autowired
private HibernateTemplate hibernateTemplate;
// 返回数值
@Override
public int getEntityForInt(String sql,Object... args) throws Exception {
// TODO Auto-generated method stub
return jdbcTemplate.queryForInt(sql,args);
}

@Override
public List<Map<String, Object>> getEntityQuery(String sql, Object... args)
throws Exception {
// TODO Auto-generated method stub
return jdbcTemplate.queryForList(sql, args);
}

@Override
public void deleteEntityForInt(String sql, int key) throws Exception {
// TODO Auto-generated method stub
jdbcTemplate.update(sql, key);
}

@Override
public void updateEntityForObject(String sql, Object ... args) throws Exception {
// TODO Auto-generated method stub
jdbcTemplate.update(sql, args);
}

@Override
public void addEntityForObject(String sql, Object... args) throws Exception {
// TODO Auto-generated method stub
jdbcTemplate.update(sql, args);
}

@Override
public void hupdateEntityForObject(Object object) throws Exception {
// TODO Auto-generated method stub
hibernateTemplate.saveOrUpdate(object);
}

@Override
public void HaddEntityForObject(Object object) throws Exception {
// TODO Auto-generated method stub
hibernateTemplate.save(object);
}

}

内容部分来自网上，有些出处已经找不到，多多担待，文章只单纯个人总结，如不好勿喷。本人QQ:373965070