首先我们要明白什么是框架为什么用？相信一开始学习编程的时候都会听到什么、什么框架之类的；首先框架是一个软件半成品，都会预先实现一些通用功能，使用框架直接应用这些通用功能而不用重新实现，所以大多数企业都用框架都是提高开发效率，节约开发成本。
绝大多数框架都遵循着一种mvc设计模式思想，MVC是Model—View—Controler的简称。即模型—视图—控制器。MVC是一种设计模式，它强制性的把应用程序的输入、处理和输出分开。MVC中的模型、视图、控制器它们分别担负着不同的任务。
视图: 视图是用户看到并与之交互的界面。视图向用户显示相关的数据，并接受用户的输入。视图不进行任何业务逻辑处理。
模型: 模型表示业务数据和业务处理。相当于JavaBean。一个模型能为多个视图提供数据。这提高了应用程序的重用性
控制器: 当用户单击Web页面中的提交按钮时,控制器接受请求并调用相应的模型去处理请求。
从上图可以看出mvc工作场景：MVC的处理过程：首先控制器接受用户的请求，调用相应的模型来进行业务处理，并返回数据给控制器。控制器调用相应的视图来显示处理的结果。并通过视图呈现给用户。
然后再看看给予mvc模式的经典的框架SSH：分别是Struts、Spring、Hibernate 。
首先介绍struts2框架：
1、基于MVC模式的应用层框架技术！
2、Struts2主要是通过Action动作类，处理请求！ (与传统的servlet开发相比，只需要写Action类即可！用Action取代之前的servlet开发！) (Struts是对servletApi进行的封装！)
3、 Struts2的发展 ：Struts2=Struts1 + xwork
4、Struts2功能的引入，是通过核心过滤器完成的! 如果想用struts的任何功能，必须经过核心过滤器！(被过滤器拦截！) (struts提供的标签的访问，要先经过核心过滤器：StrutsPrepareAndExecuteFilter！)
还有struts2提供了一些简单的功能，方便开发；例如文件的上传，请求数据封装；代码如下
封装数据请求一：
<body>
<form action="${pageContext.request.contextPath }/register.action" method="post">
注册用户：<input type="text" name="userName"> <br/>
注册密码：<input type="text" name="pwd"> <br/>
<input type="submit" value="注册!">
</form>
</body>
public class UserAction extends ActionSupport {
// 封装请求数据，方式1：
private String userName;
// request.getParameter(“userName”)
// 把值作为方法参数传入！
public void setUserName(String userName) {
this.userName = userName;
}
private String pwd;
public void setPwd(String pwd) {
this.pwd = pwd;
}
@Override
public String execute() {
System.out.println(userName + "\t" + pwd);
return "success";
}
}封装数据请求二：
注册用户：<input type="text" name="user.userName"> <br/>
注册密码：<input type="text" name="user.pwd"> <br/>public class UserAction extends ActionSupport {
// 封装请求数据,
private User user;
public void setUser(User user) {
this.user = user;
}
// 注意：如果是基本类型只用给set方法即可； 如果是对象，必须给set和get!
public User getUser() {
return user;
}
}从上面两种请求可以看出：一个是作为基本类型也就是字符串，另一个是对象。大多数用到的都是第二种。
struts2的配置文件简单介绍一下struts2默认访问后缀是.action最为后缀 ， 默认执行的方法是execute!
struts2的配置文件大概是这样的
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
"http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
<!--
1. package 包
作用： 管理action或管理路径的作用!
name
表示包名称！ 作用，被其他包继承！
<package name="base" extends="struts-default"></package>
<package name="config" extends="base">
包名不能重复！
extends
当前包表必须继承struts-default包！
(struts-default.xml 中定义了这个包！)
abstract="true"
抽象包中不能有action配置！主要被其他包继承的！
namespace
名称空间，管理路径！作为路径的一部分！
默认值：/
访问路径 = namespace + actionName
举例：http://localhost:8080/day27_struts01/user/update.action
路径匹配原则：
http://localhost:8080/day27_struts01/user/a/b/c/update.action OK
http://localhost:8080/day27_struts01/user/a/b/update.action OK
http://localhost:8080/day27_struts01/user/a/update.action OK
http://localhost:8080/day27_struts01/user/update.action OK
http://localhost:8080/day27_struts01/a/user/update.action NOK
总结：
localhost 本机IP
8080 Tomcat
/day27_struts01 通常是%tomcat%/webapps下部署项目名称！
struts获取：
/user/a/b/c/update.action
截取得到：
/user/a/b/c 名称空间部分
去这个名称空间找action name 是"update" 的路径，没有，就向上一级目录查找
/user/a/b 去这个名称找，没有"update", 向上一层找
/user/a 没有
/user 有则返回（不往下查找！） ； 如果没有，去默认名称空间找
/ 没有找到，则404！
2. action 节点
作用： 配置访问路径，与，处理action类的映射关系！
name
与名称空间共同组成访问路径！
class
处理action类的全名!
method
当前请求的处理方法!
如果不写，默认是execute!
result 子节点
作用： action类的业务处理方法的返回的跳转标记，与跳转页面的映射关系！
name
action类中方法返回的String
type
表示跳转的类型！ (可写值的定义，在struts-default.xml中！)
默认是:dispatcher， 为转发！
dispacher 默认值； 转发
redirect 重定向
标签体中可以指定跳转的页面！
-->
<package name="config" namespace="/user" extends="struts-default">
<!-- 配置Action -->
<action name="user" class="cn.itcast.b_config.UserAction" method="execute">
<result name="success" type="redirect">/index.jsp</result>
</action>
</package>
</struts>在介绍一下struts的工作原理吧
1.客户端发出一个指向servlet容器的请求；
2.请求会经过StrutsPrepareAndExecuteFilter过滤器；
3.过滤器和请求将访问struts2的底层框架结构。在web容器启动时，struts2框架会自动加载配置文件里相关参数，并转换成相应的类。
如：ConfigurationManager、ActionMapper和ObjectFactory。ConfigurationManager 存有配置文件的一些基本信息，ActionMapper存有action的配置信息。在请求过程中所有的对象（Action，Results，Interceptors，等）都是通过ObjectFactory来创建的。过滤器会通过询问ActionMapper类来查找请求中需要用到的Action。
4.如果找到需要调用的Action，过滤器会把请求的处理交给ActionProxy。ActionProxy为Action的代理对象。ActionProxy通过ConfigurationManager询问框架的配置文件，找到需要调用的Action类。
5.ActionProxy创建一个ActionInvocation的实例。ActionInvocation在ActionProxy层之下，它表示了Action的执行状态,或者说它控制的Action的执行步骤。它持有Action实例和所有的Interceptor。
6.ActionInvocation实例使用命名模式来调用，1. ActionInvocation初始化时，根据配置，加载Action相关的所有Interceptor。2. 通过ActionInvocation.invoke方法调用Action实现时，执行Interceptor。在调用Action的过程前后，涉及到相关拦截器(intercepetor)的调用。
7. 一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。
这些类不要太在意，大概知道干什么就可以了，如果想学精通就要查看底层类是使怎么写的，大多数框架都有技术文档
通俗的来讲：
1、发送http请求
2、Web服务器(tomcat/weblogic...)
3、执行struts核心过滤器StrutsPrepareAndExecuteFilter
4、加载struts配置文件中配置信息，找到对应的Action类并实例化
5、执行各类拦截器和Action中对应方法
6、配置文件中找到返回结果
7、转发到具体页面或其它操作
大概是这样
struts还有一个拦截器的概念：Interceptor 表示拦截器！struts2是通过一个个拦截器来完成通用的功能的。
struts2大概介绍到这里，还有其他知识自己学习吧！
Hibernate框架：
首先我们要明白一个东西那就是ORM规则：Object Relation Mapping 对象关系映射！
所有简单来说Hibernate就是一个操作数据库的东西一般有两个配置文件，一个是关系对象配置文件，一个是主配置文件。例如：User.java
// 封装数据
public class User {
private int id;
private String name;
private char sex;
private Date birth;
}User.hbm.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="cn.itcast.a_hello.User" table="t_user">
<id name="id" column="uid">
<generator class="native"></generator>
</id>
<property name="name" column="uname"></property>
<property name="sex" column="sex"></property>
<property name="birth" column="birth"></property>
</class>
</hibernate-mapping>还有一个主配置文件hibernate.cfg.xml（核心配置文件）
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- 1. 数据库连接信息 -->
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql:///day31</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.show_sql">true</property>
<!-- 3. 加载所有的映射 -->
<mapping resource="User.hbm.xml"/>
</session-factory>
</hibernate-configuration>写一个类测试一些
public class App {
// 用Hibernate，不写sql，保存对象!
@Test
public void testSave() {
// 对象
User user = new User();
user.setName("测试");
user.setSex('它');
user.setBirth(new Date());
// 创建配置管理器对象
Configuration config = new Configuration();
// 加载主配置文件: hibernate.cfg.xml
config.configure();
// 根据加载的主配置文件，创建Sessionfactory对象！
SessionFactory sf = config.buildSessionFactory();
// 创建session (维护了一个连接！)
Session session = sf.openSession();
// 开启事务
Transaction tx = session.beginTransaction();
// --- 保存 ----
session.save(user);
// 提交事务、关闭session
tx.commit();
session.close();
}
// 用Hibernate，不写sql，查询对象!
@Test
public void testGet() throws Exception {
Configuration config = new Configuration();
config.configure();
SessionFactory sf = config.buildSessionFactory();
Session session = sf.openSession();
Transaction tx = session.beginTransaction();
//--- 操作 --
User user = (User) session.get(User.class, 2);
System.out.println(user);
tx.commit();
session.close();
}
}hibernate执行流程图如下：
原理： 1.读取并解析配置文件 2.读取并解析映射信息，创建SessionFactory 3.打开Session 4.创建事务Transation 5.持久化操作 6.提交事务 7.关闭Session 8.关闭SesstionFactory
Spring框架：
spring框架有6大功能模块，需要用到那个模块就引用哪个模块，但核心模块必须引用
分别是：Spring Core 核心功能，SpringAop 面向切面编程，SpringWeb 对web开发的支持（spring对struts框架的支持!），SpringJdbc 对jdbc的支持，SpringORM 对ORM的支持（spring对hibenrate的支持），SpringJEE 对javaee其他模块的支持!(EJB)
可以看出Spring 主要是创建创建，与其他框架整合，表示可以帮其他框架创建对象！
举个简单例子如何创建对象
@Test
public void testapp() throws Exception {
// 获取容器创建的对象
ApplicationContext ac =
new ClassPathXmlApplicationContext("Spring的xml文件路径");
//从容器获取创建的对象
Date d = (Date) ac.getBean("date");
System.out.println(d);
User user = (User) ac.getBean("user");
}就简单介绍一下
Spring核心， 就是指IOC容器！
IOC容器，
主要是创建对象！
Inversion of control 控制反转！ 所以，也叫控制反转容器！
控制反转，
对象的创建交给外部容器完成，程序需要对象，只需要从容器获取即可！
IOC容器 = applicationContex.xml + ApplicationContext类
创建对象之后，给对象属性赋值， 这个叫“依赖注入”！
spring的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:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>里面的一些配置就需要自己查看相应的文档
这些框架都有自己的配置文件，都有相应的技术文档，所有不要觉得框架很难。总的来说学习这些框架式很容易入手的，那就是多练习，然后在上网（大多数在论坛上都有项目）找几个项目做。一个人的学习经验来说，都是模仿别人的项目，自己敲多几次就会了，好好学习吧
