首先我们要明白什么是框架为什么用?相信一开始学习编程的时候都会听到什么、什么框架之类的;首先框架是一个软件半成品,都会预先实现一些通用功能,使用框架直接应用这些通用功能而不用重新实现,所以大多数企业都用框架都是提高开发效率,节约开发成本。

  绝大多数框架都遵循着一种mvc设计模式思想,MVC是Model—View—Controler的简称。即模型—视图—控制器。MVC是一种设计模式,它强制性的把应用程序的输入、处理和输出分开。MVC中的模型、视图、控制器它们分别担负着不同的任务。 

    视图: 视图是用户看到并与之交互的界面。视图向用户显示相关的数据,并接受用户的输入。视图不进行任何业务逻辑处理。 

    模型: 模型表示业务数据和业务处理。相当于JavaBean。一个模型能为多个视图提供数据。这提高了应用程序的重用性 

    控制器: 当用户单击Web页面中的提交按钮时,控制器接受请求并调用相应的模型去处理请求。

  

javaee视图 java视图作用_struts

  从上图可以看出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  对象关系映射!

javaee视图 java视图作用_配置文件_02

所有简单来说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执行流程图如下:

javaee视图 java视图作用_配置文件_03

原理: 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)

javaee视图 java视图作用_javaee视图_04

可以看出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>

里面的一些配置就需要自己查看相应的文档

这些框架都有自己的配置文件,都有相应的技术文档,所有不要觉得框架很难。总的来说学习这些框架式很容易入手的,那就是多练习,然后在上网(大多数在论坛上都有项目)找几个项目做。一个人的学习经验来说,都是模仿别人的项目,自己敲多几次就会了,好好学习吧