Java Web开发模式

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java Web开发模式，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含17312字，纯文字阅读大概需要25分钟。

内容图文

一 Java Web开发模式的变迁

1 最初的Java web服务器端编程技术是Servlet，利用Servlet就可以开发出一个Web应用程序。

2 为了解决Servlet缺陷，SUN推出了JSP技术。但是开发人员又走向了另一个极端就是完全放弃了Servlet。

在JSP页面混合使用HTML标记和java代码编写的脚本元素标记来开发Web程序。采用这种方法虽然可以编写JSP页面变得简单，直观，然而，他只适合于业务流程简单，系统规模较小的应用系统。

如果系统较大的话，就会出现两个严重的缺点：

1) 页面严重缺乏可读性。

2) 没有将页面表现和业务逻辑实现分开，使维护难度增加了。

在JSP中使用JavaBean可以实现页面与逻辑业务分开。

3 SUN公司将在Web应用开发中使用JSP+JavaBean技术。===JSP模式1 (适用于规模较小，业务逻辑简单的web应用开发)。

4 SUN在java web开发中引入了MVC架构模式，利用Servlet，JSP，JavaBean技术（讲servlet作为MVC架构模式中的控制器，JSP作为视图，javabean作为模型）===JSP模式2（）这也不是绝对完美的。

二在JSP中使用JavaBean

一个标准的JavaBean组件具有以下几个特征

             1
            package
             com.cy.bean;

             2
             3
            import
             java.io.Serializable;

             4
             5
            /*
            JavaBean 类必须是一个公共类，并将其访问属性设置为 public。
            */
             6
            /*
            JavaBean应该是可序列化(serializable)的，即实现java.io.Serializable 接口  
            */
             7
             8
            public
            class User implements Serializable {
 9privatestaticfinallong serialVersionUID = 1L;
10/* 一个JavaBean类不应有公共实例变量，类变量都为private */11privateint id;
12private String name;
13private String pwd;
14privateint postion;
1516/* JavaBean 类必须有一个空的构造函数，（系统会默认一个无参构造器，如果没有其他的构造器） */17public User() {
18super();
19    }
2021/* 要访问这些类变量，应该通过一组存取方法（getXxx 和 setXxx）来访问， */22publicint getId() {
23return id;
24    }
2526publicvoid setId(int id) {
27this.id = id;
28    }
2930public String getName() {
31return name;
32    }
3334publicvoid setName(String name) {
35this.name = name;
36    }
3738public String getPwd() {
39return pwd;
40    }
4142publicvoid setPwd(String pwd) {
43this.pwd = pwd;
44    }
4546publicint getPostion() {
47return postion;
48    }
4950publicvoid setPostion(int postion) {
51this.postion = postion;
52    }
5354 }

为了在JSP页面中使用JavaBean，SUN在JSP规范中提供了三种标准动作。

1 <jsp:useBean>动作得到或者创建一个JavaBean对象

语法形式：

<jsp:useBean id=“beanName” //变量名 scope=“page|request|session|application” //作用范围 class=“className” //类全路径/>

                1
                <
                jsp:useBean 
                id
                ="user"
                 class
                ="com.cy.bean.User"
                 scope
                ="request"
                ></
                jsp:useBean
                >

id:代表bean的引用名，id在一个页面中必须是一个唯一的值；User user = new User();

scope: 指定JavaBean生存的作用域

type:id的引用的数据类型，默认情况下，它与class的类型相同。

2 <jsp:getProperty>动作可以把JavaBean的某个属性取出来

语法形式：

<jsp:getProperty name="beanname" property="propertyname"/>

1<jsp:getProperty property="name" name="user"/>

property: 指的是返回JavaBean中的相对应的属性名

3 <jsp:setProperty>动作设置JavaBean的属性值

其有四种语法形式：

<jsp:setProperty name="BeanName" property="属性名"/>

<jsp:setProperty name="BeanName" property="属性名" param="参数名"/>

<jsp:setProperty name="BeanName" property="属性名" value="属性值" />

<jsp:setProperty name="BeanName" property="*"/>

                        1
                        ----.jsp

                        2
                        <
                        jsp:setProperty 
                        property
                        ="name"
                         name
                        ="user"
                         param
                        ="username"
                        />
                        3
                        <
                        jsp:setProperty 
                        property
                        ="pwd"
                         name
                        ="user"
                         param
                        ="pwd"
                        />
                        4
                        5
                        6
                        ----.html

                        7  username:<input type="text" name="username"/>8    pwd  :<input type ="password" name="pwd"/>

property:JavaBean相对应的属性

value设置属性的值

param将property指定的属性名的值设置为一个请求参数的值

property="*"用来设置所有与所得到的参数同名的属性值

三 JSP开发模式1

JSP模式1主要采用JSP和JavaBean技术

将页面显示与业务逻辑处理分开

JSP负责页面的显示，而业务逻辑则由JavaBean处理

用户登录案例来说明JSP1开发模式：

UserBean.java

                             1
                            package
                             com.cy.bean;

                             2
                             3
                            import
                             java.io.Serializable;

                             4
                             5
                             6
                             7
                            public
                            class UserBean implements Serializable {
 8privatestaticfinallong serialVersionUID = 1L;
 910private String name;
11private String pwd;
1213public UserBean () {
14super();
15    }
161718public String getName() {
19return name;
20    }
2122publicvoid setName(String name) {
23this.name = name;
24    }
2526public String getPwd() {
27return pwd;
28    }
2930publicvoid setPwd(String pwd) {
31this.pwd = pwd;
32    }
333435 }

                             1
                            <!
                            DOCTYPE html
                            >
                             2
                            <
                            html
                            >
                             3
                            <
                            head
                            >
                             4
                            <
                            title
                            >login.html</title> 5 6<meta name="keywords" content="keyword1,keyword2,keyword3"> 7<meta name="description" content="this is my page"> 8<meta name="content-type" content="text/html; charset=UTF-8"> 910<!--<link rel="stylesheet" type="text/css" href="./styles.css">-->1112</head>1314<body>15<form action="/java_web/CheckUser.jsp" method="post">16    username:<input type="text" name="username"/>17    pwd  :<input type ="password" name="pwd"/>18<input type="submit" value="submit"/>19</form>20</body>21</html>

CheckUserBean.java

                             1
                            package
                             com.cy.bean;

                             2
                             3
                            import
                             java.sql.Connection;

                             4
                            import
                             java.sql.DriverManager;

                             5
                            import
                             java.sql.ResultSet;

                             6
                            import
                             java.sql.SQLException;

                             7
                            import
                             java.sql.Statement;

                             8
                             9
                            public
                            class
                             CheckUserBean {

                            10
                            11
                            public
                            boolean
                             checkUser(User user) {

                            12
                            13         String name = user.getName();
14         String pwd = user.getPwd();
15         Connection conn = null;
16         Statement st = null;
17         ResultSet rs = null;
18         String url = "jdbc:mysql://localhost:3306/demo";
19         String user1 = "root";
20         String password = "1234";
21         String sql = "select * from t_user where user_name=‘" + name
22                 + "‘ and user_password=‘" + pwd + "‘";
23try {
24             Class.forName("com.mysql.jdbc.Driver");
25             conn = DriverManager.getConnection(url, user1, password);
26             st = conn.createStatement();
27             rs = st.executeQuery(sql);
2829if (rs.next()) {
30returntrue;
31            }
32         } catch (Exception e) {
33            e.printStackTrace();
34         } finally {
35try {
36                rs.close();
37                st.close();
38                conn.close();
39             } catch (SQLException e) {
40                e.printStackTrace();
41            }
42        }
4344returnfalse;
4546    }
47 }

CheckUser.jsp

 1<%@ page language="java" import="java.util.*,com.cy.bean.*" pageEncoding="utf-8"%> 2<% 3String path = request.getContextPath();
 4String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
 5%> 6 7<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> 8<html> 9<head>10<base href="<%=basePath%>">1112<title>My JSP ‘CheckUser.jsp‘ starting page</title>1314<meta http-equiv="pragma" content="no-cache">15<meta http-equiv="cache-control" content="no-cache">16<meta http-equiv="expires" content="0">17<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">18<meta http-equiv="description" content="This is my page">19<!--20    <link rel="stylesheet" type="text/css" href="styles.css">
21-->2223</head>2425<body>26<%CheckUserBean cub=new CheckUserBean(); %>27<jsp:useBean id="user" class="com.cy.bean.User" scope="request"></jsp:useBean>28<jsp:setProperty property="*" name="user"/>29<%if(cub.checkUser(user)) {%>30<jsp:forward page="success.jsp"></jsp:forward>31<%}else{%>32<jsp:forward page="fail.jsp"></jsp:forward>33<%} %>34</body>35</html>

success.jsp

                             1
                            <%
                            @ page language
                            =
                            "
                            java
                            "
                             import
                            =
                            "
                            java.util.*
                            "
                             pageEncoding
                            =
                            "
                            utf-8
                            "
                            %>
                             2
                            <%
                             3
                            String
                             path 
                            =
                             request.getContextPath();

                             4
                            String
                             basePath 
                            =
                             request.getScheme()
                            +
                            "
                            ://
                            "
                            +
                            request.getServerName()
                            +
                            "
                            :
                            "
                            +
                            request.getServerPort()
                            +
                            path
                            +
                            "
                            /
                            "
                            ;

                             5
                            %>
                             6
                             7
                            <!
                            DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
                            >
                             8
                            <
                            html
                            >
                             9
                            <
                            head
                            >
                            10
                            <
                            base 
                            href
                            ="<%=basePath%>"
                            >
                            11
                            12
                            <
                            title
                            >My JSP ‘success.jsp‘ starting page</title>1314<meta http-equiv="pragma" content="no-cache">15<meta http-equiv="cache-control" content="no-cache">16<meta http-equiv="expires" content="0">17<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">18<meta http-equiv="description" content="This is my page">19<!--20    <link rel="stylesheet" type="text/css" href="styles.css">
21-->2223</head>2425<body>26<jsp:useBean id="user" class="com.cy.bean.User" scope="request"></jsp:useBean>2728    欢迎你：<jsp:getProperty property="name" name="user"/>29</body>30</html>

四 JSP开发模式2

JSP开发模式2借鉴了MVC架构模式，采用了Servlet+JSP+JavaBean的技术实现JavaWeb的开发。

1 MVC架构

在MVC中，模型（model）部分负责管理系统业务数据，视图（view）部分负责显示界面，控制器（controller）部分负责与用户的交互。

MVC示意图

2 MVC架构模式的Java Web实现

JSP开发模式2借鉴了MVC架构模式，采用了Servlet+JSP+JavaBean的技术实现JavaWeb的开发。

Servlet充当控制器额角色，负责处理请求和控制业务流程；

JSP充当视图的角色，负责输出响应结果；

JavaBean充当模型的角色，负责具体的业务逻辑和业务数据。

其结构如图：

WebMVC

3 JSP模式2开发步骤

–1 定义一系列Bean来表示数据

–2 使用一个Servlet来处理请求

–3 在Servlet中填充Bean

–4 在Servlet中，将Bean存储到请求、会话或者Servlet上下文中

–5 将请求转发到JSP页面

–6 在JSP页面中，从Bean中提取数据

1）

由于在MVC中，都是有Servlet或者其他的JAVA程序中创建Bean，所以我们开发的JavaBean也就不再需要有空构造器方法。

                                 1
                                package
                                 com.cy.bean;

                                 2
                                 3
                                import
                                 java.io.Serializable;

                                 4
                                 5
                                public
                                class User implements Serializable {
 6 7private String name;
 8private String pwd;
 910public String getName() {
11return name;
12    }
1314publicvoid setName(String name) {
15this.name = name;
16    }
1718public String getPwd() {
19return pwd;
20    }
2122publicvoid setPwd(String pwd) {
23this.pwd = pwd;
24    }    
2526 }

–2 ) 使用一个Servlet来处理请求

–3 )在Servlet中填充Bean

–4 )在Servlet中，将Bean存储到请求、会话或者Servlet上下文中

–5 )将请求转发到JSP页面

                                 1
                                package
                                 com.cy.servlet;

                                 2
                                 3
                                import
                                 java.io.IOException;

                                 4
                                import
                                 java.sql.Connection;

                                 5
                                import
                                 java.sql.DriverManager;

                                 6
                                import
                                 java.sql.ResultSet;

                                 7
                                import
                                 java.sql.SQLException;

                                 8
                                import
                                 java.sql.Statement;

                                 9
                                10
                                import
                                 javax.servlet.ServletException;

                                11
                                import
                                 javax.servlet.http.HttpServlet;

                                12
                                import
                                 javax.servlet.http.HttpServletRequest;

                                13
                                import
                                 javax.servlet.http.HttpServletResponse;

                                14
                                15
                                import
                                 com.cy.bean.User;

                                16
                                //
                                 需要连接数据库
                                17
                                public
                                class LoginServlet extends HttpServlet{
1819    @Override
20protectedvoid doGet(HttpServletRequest req, HttpServletResponse resp)
21throws ServletException, IOException {
22         req.setCharacterEncoding("utf-8");
23         resp.setCharacterEncoding("utf-8");    
24         resp.setContentType("text/html;charset=utf-8");
2526/*使用一个Servlet来处理请求    */27         String name = req.getParameter("username");
28         String pwd = req.getParameter("pwd");
29303132         Connection conn = null;
33         Statement st = null;
34         ResultSet rs = null;
35         String url="jdbc:mysql://localhost:3306/demo";
36         String user = "root";
37         String password  ="1234";
38         String sql = "select * from t_user where user_name=‘"+name+"‘ and user_password=‘"+pwd+"‘";
3940//System.out.println(sql);41try {
42             Class.forName("com.mysql.jdbc.Driver");
43             conn = DriverManager.getConnection(url,user,password);
44             st = conn.createStatement();
45             rs = st.executeQuery(sql);
46if(rs.next()){
4748/*    在Servlet中填充Bean*/49                 User u = new User();
50                u.setPwd(pwd);
51                u.setUsername(name);
525354/*在Servlet中，将Bean存储到请求、会话或者Servlet上下文中*/55                 req.getSession().setAttribute("user", u);
5657/*将请求转发到JSP页面*/58                 req.getRequestDispatcher("/welcome.jsp").forward(req, resp);
59             }else{
60                 req.getRequestDispatcher("/index.jsp").forward(req, resp);
61            }
62         } catch (Exception e) {
63            e.printStackTrace();
64         }finally{
65try {
66                rs.close();
67                st.close();
68                conn.close();
69             } catch (SQLException e) {
70                e.printStackTrace();
71            }
72        }
7374    }
7576    @Override
77protectedvoid doPost(HttpServletRequest req, HttpServletResponse resp)
78throws ServletException, IOException {
79        doGet(req, resp);
80    }
8182 }

这里还写了一个简单的util

                                 1
                                package
                                 com.cy.util;

                                 2
                                 3
                                import
                                 java.sql.Connection;

                                 4
                                import
                                 java.sql.DriverManager;

                                 5
                                import
                                 java.sql.ResultSet;

                                 6
                                import
                                 java.sql.SQLException;

                                 7
                                import
                                 java.sql.Statement;

                                 8
                                 9
                                public
                                class
                                 DBUtil {

                                10
                                private
                                static String url = "jdbc:mysql://127.0.0.1:3306/demo?useUnicode=true&characterEncoding=utf-8"; 
11privatestatic String user = "root";
12privatestatic String pwd = "1234";
13private DBUtil(){};
14static{
15try {
16             Class.forName("com.mysql.jdbc.Driver");
17         } catch (ClassNotFoundException e) {
18            e.printStackTrace();
19        }
2021    }
2223publicstatic Connection getConn() throws SQLException{
24return DriverManager.getConnection(url,user,pwd);
25    }
2627publicstaticvoid closeRe(Connection conn,Statement st,ResultSet rs){
28if(rs!=null){
29try {
30                rs.close();
31             } catch (SQLException e) {
32                e.printStackTrace();
33             }finally{
34if(st!=null){
35try {
36                        st.close();
37                     } catch (SQLException e) {
38                        e.printStackTrace();
39                     }finally{
40if(conn!=null){
41try {
42                                conn.close();
43                             } catch (SQLException e) {
44                                e.printStackTrace();
45                            }
46                        }
47                    }
48                }
49            }
50        }
51    }
5253publicstaticvoid closeRe(Connection conn,Statement st) {
54if(st!=null){
55try {
56                st.close();
57             } catch (SQLException e) {
58                e.printStackTrace();
59             }finally{
60if(conn!=null){
61try {
62                        conn.close();
63                     } catch (SQLException e) {
64                        e.printStackTrace();
65                    }
66                }
67            }
68        }
6970    }
7172 }

在web.xml配置Servlet

                                 1
                                <?
                                xml version="1.0" encoding="UTF-8"
                                ?>
                                 2
                                <
                                web-app 
                                version
                                ="2.5"
                                 xmlns
                                ="http://java.sun.com/xml/ns/javaee"
                                 3
                                    xmlns:xsi
                                ="http://www.w3.org/2001/XMLSchema-instance"
                                 4
                                    xsi:schemaLocation
                                ="http://java.sun.com/xml/ns/javaee 

                                 5
                                    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
                                >
                                 6
                                <
                                display-name
                                ></
                                display-name
                                >
                                 7
                                <
                                welcome-file-list
                                >
                                 8
                                <
                                welcome-file
                                >index.jsp</welcome-file> 9</welcome-file-list>1011<servlet>12<servlet-name>login</servlet-name>13<servlet-class>com.cy.servlet.LoginServlet</servlet-class>14</servlet>1516<servlet-mapping>17<servlet-name>login</servlet-name>18<url-pattern>/login</url-pattern>19</servlet-mapping>2021</web-app>

在JSP页面中，从Bean中提取数据

                             1
                            <%
                            @ page language
                            =
                            "
                            java
                            "
                             import
                            =
                            "
                            java.util.*
                            "
                             pageEncoding
                            =
                            "
                            utf-8
                            "
                            %>
                             2
                            <%
                             3
                            String
                             path 
                            =
                             request.getContextPath();

                             4
                            String
                             basePath 
                            =
                             request.getScheme()
                            +
                            "
                            ://
                            "
                            +
                            request.getServerName()
                            +
                            "
                            :
                            "
                            +
                            request.getServerPort()
                            +
                            path
                            +
                            "
                            /
                            "
                            ;

                             5
                            %>
                             6
                             7
                            <!
                            DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
                            >
                             8
                            <
                            html
                            >
                             9
                            <
                            head
                            >
                            10
                            <
                            base 
                            href
                            ="<%=basePath%>"
                            >
                            11
                            12
                            <
                            title
                            >My JSP ‘welcome.jsp‘ starting page</title>1314<meta http-equiv="pragma" content="no-cache">15<meta http-equiv="cache-control" content="no-cache">16<meta http-equiv="expires" content="0">17<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">18<meta http-equiv="description" content="This is my page">19<!--20    <link rel="stylesheet" type="text/css" href="styles.css">
21-->2223</head>2425<body>26  welcome页码显示数据
27<jsp:useBean id="user" type="com.cy.bean.User" scope="session"></jsp:useBean>28<p>欢迎你：<jsp:getProperty property="name" name="user"></jsp:getProperty></p>29</body>30</html>

五在MVC中使用过滤器

在创建Bean后，Servlet使用RequestDispatcher 对象将请求转发到恰当的JSP页面

Servlet

                             1
                            package
                             com.cy.servlet;

                             2
                             3
                            import
                             java.io.IOException;

                             4
                             5
                            import
                             javax.servlet.ServletException;

                             6
                            import
                             javax.servlet.http.HttpServlet;

                             7
                            import
                             javax.servlet.http.HttpServletRequest;

                             8
                            import
                             javax.servlet.http.HttpServletResponse;

                             9
                            10
                            import
                             com.cy.bean.User;

                            11
                            12
                            public
                            class DemoServlet extends HttpServlet {
1314    @Override
15protectedvoid doGet(HttpServletRequest req, HttpServletResponse resp)
16throws ServletException, IOException {
17         req.setCharacterEncoding("utf-8");
18         String name = req.getParameter("username");
19         String pwd = req.getParameter("pwd");
2021         User user = new User();
22        user.setPwd(pwd);
23        user.setUsername(name);
24         req.getSession().setAttribute("user1", user);
25         String uri = req.getRequestURI();
26        req.getRequestDispatcher(uri).forward(req, resp);
27    }
2829    @Override
30protectedvoid doPost(HttpServletRequest req, HttpServletResponse resp)
31throws ServletException, IOException {
32        doGet(req, resp);
33    }
3435 }

Filter

                             1
                            package
                             com.cy.filter;

                             2
                             3
                            import
                             java.io.IOException;

                             4
                             5
                            import
                             javax.servlet.Filter;

                             6
                            import
                             javax.servlet.FilterChain;

                             7
                            import
                             javax.servlet.FilterConfig;

                             8
                            import
                             javax.servlet.ServletException;

                             9
                            import
                             javax.servlet.ServletRequest;

                            10
                            import
                             javax.servlet.ServletResponse;

                            11
                            import
                             javax.servlet.http.HttpServletRequest;

                            12
                            13
                            import
                             com.lovo.bean.User;

                            14
                            15
                            public
                            class DemoFilter implements Filter {
1617publicvoid destroy() {
18// TODO Auto-generated method stub1920    }
2122publicvoid doFilter(ServletRequest arg0, ServletResponse arg1,
23             FilterChain arg2) throws IOException, ServletException {
24         HttpServletRequest req = (HttpServletRequest)arg0;
25         User user = new User();
26         String name = req.getParameter("username");
27         String pwd = req.getParameter("pwd");
28        user.setPwd(pwd);
29        user.setUsername(name);
30         req.getSession().setAttribute("user", user);
31        arg2.doFilter(req, arg1);
32    }
3334publicvoid init(FilterConfig arg0) throws ServletException {
35// TODO Auto-generated method stub3637    }
3839 }

在web.xml中配置部署Filter，servlet

                             1
                            <?
                            xml version="1.0" encoding="UTF-8"
                            ?>
                             2
                            <
                            web-app 
                            version
                            ="2.5"
                             xmlns
                            ="http://java.sun.com/xml/ns/javaee"
                             3
                                xmlns:xsi
                            ="http://www.w3.org/2001/XMLSchema-instance"
                             4
                                xsi:schemaLocation
                            ="http://java.sun.com/xml/ns/javaee 

                             5
                                http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
                            >
                             6
                            <
                            display-name
                            ></
                            display-name
                            >
                             7
                            <
                            welcome-file-list
                            >
                             8
                            <
                            welcome-file
                            >index.jsp</welcome-file> 9</welcome-file-list>1011<filter>12<filter-name>jsp</filter-name>13<filter-class>com.cy.filter.DemoFilter</filter-class>14</filter>15<filter-mapping>16<filter-name>jsp</filter-name>17<url-pattern>/*</url-pattern>18</filter-mapping>193031</web-app>

小结：

1 JSP脚本使页面变得简单、直观，但可读性差而且没有将页面表现和业务逻辑实现分开，维护难度增加

2 JSP的主要任务是发送文本内容的响应，Servlet控制业务流程但是无法对业务功能进行复用

3 使用JavaBean把业务逻辑从Servlet中取出来

4 JavaBean本质上就是一个普通的Java类

5 MVC设计模式让Servlet负责处理请求和控制业务流程，JSP负责输出响应结果，JavaBean负责具体的业务逻辑和业务数据

6 在MVC模式处理中最后的显示结果是由Servlet代码来判断请求要转发到哪个JSP页面

7 采用过滤器作为控制器，提供了一个清晰的方法来增加一个新视图

原文：http://www.cnblogs.com/hellokitty1/p/4954376.html

内容总结

以上是互联网集市为您收集整理的Java Web开发模式全部内容，希望文章能够帮你解决Java Web开发模式所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1285735.html

来源：【匿名】

【上一篇】java自定义注解并解读【下一篇】JAVA/JSP学习系列之五

更多 ►

【Java Web开发模式】教程文章相关的互联网学习教程文章

一 Java Web开发模式的变迁1 最初的Java web服务器端编程技术是Servlet，利用Servlet就可以开发出一个Web应用程序。2 为了解决Servlet缺陷，SUN推出了JSP技术。但是开发人员又走向了另一个极端就是完全放弃了Servlet。在JSP页面混合使用HTML标记和java代码编写的脚本元素标记来开发Web程序。采用这种方法虽然可以编写JSP页面变得简单，直观，然而，他只适合于业务流程简单，系统规模较小的应用系统。如果系统较大的话，就会出现...

java web开发入门一（servlet和jsp）基于eclispe【代码】

servlet用java语言开发动态资源网站的技术，在doGet方法中拼接显示html，在doPost方法中提交数据。类似于.net的ashx技术。servlet生成的class文件存放在tomcat中webapps目录下。1.开发一个servlet步骤：　　1）在src下新建包并编写java类，继承HttpServlet类　　2）重写doGet和doPost方法package com.eggtwo.boss;import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.annotation.WebServle...

JAVA web开发模式【图】

jsp页面的运行阶段分为：翻译、编译、类装载、类实例化、初始化、服务、销毁七个阶段JSP网页主要由元素和模板数据两个部分组成jsp元素包括：脚本元素、指令、标准动作WEB容器支持普通格式和XML兼容格式两种不同格式的JSP语法在JSP中有scriptlet、脚本表达式和声明JSP指令作用主要是页面与容器之间的通信JSP动作用于页面与页面或者页面与组件（JavaBean）之间实现通信JSP中存在操纵请求、响应、会话以及其它Servlet中使用的隐式对象...

java web开发高并发处理

转自：http://blog.csdn.net/zhangzeyuaaa/article/details/44542161 java处理高并发高负载类网站中数据库的设计方法（java教程,java处理大量数据，java高负载数据）一：高并发高负载类网站关注点之数据库没错,首先是数据库,这是大多数应用所面临的首个SPOF。尤其是Web2.0的应用，数据库的响应是首先要解决的。一般来说MySQL是最常用的，可能最初是一个mysql主机，当数据增加到100万以上，那么，MySQL的效能急剧下降。常用的优化...

高效 Java Web 开发框架 JessMA v3.5.1 正式发布【图】

????JessMA 是功能完备的高性能?Full-Stack?Web?应用开发框架，内置可扩展的?MVC?Web?基础架构和?DAO?数据库访问组件（内部已提供了?Hibernate、MyBatis?与?JDBC?DAO?组件），集成了?Action?拦截、Form?/?Dao?/?Spring?Bean?装配、国际化、文件上传下载和页面静态化等基础?Web?应用组件，提供高效灵活的纯?Jsp/Servlet?API?编程模型，可完美整合?Spring?/?Guice，支持?Action?Convention，能快速开发传统风格和?RESTful?风格应用程...

分享Java web 开发必游之路

一、开始，万事开头难啊！ Java的学习很难，因为它太庞杂了，有很多令人恐惧的（并非语言本身的）细节。让我们先看看，我们将碰到哪些难关： 1. 表示脸面的部分，这里将用到的技术和知识：JSP，Servlet，XML，HTML，JavaScript，CSS等，最好能了解网络基础（TCP/IP协议等）。 2. 业务逻辑核心的部分，这里将用到的技术和知识：Java Bean，XML等。 3. 数据库存储的部分，这里将用到的技术和知识...

学习Java Web(二)：开发SpringMVC项目

SpringMVC项目：MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。比如一批统计数据可以分别用柱状图、饼图来表示。C存在的目的则是...

java_WEB开发防刷新【代码】【图】

客户端处理：面对客户端我们可以使用Javascript脚本来解决，如下1。重复刷新、重复提交 Ways One：设置一个变量，只允许提交一次。 <script language="javascript"> var checkSubmitFlg = false; function checkSubmit() { if (checkSubmitFlg == true) { returnfalse; } checkSubmitFlg = true; returntrue; } document.ondblclick = function docondblclick() { window.event.returnValue = false; } document.o...

Java Web开发基础（3）-JSTL【图】

在DRP项目中接触到了JSTL标签库，对我这种比较懒的人来说，第一感觉就是“惊艳”。JSTL标签库的使用，可以消除大量复杂、繁复的工作。工作量减少的不是一点半点，是减少了一大半。任何工具的引入，都会使我们的工作变的简单，但是问题是我们工作可以变的简单，但是我们不能让自己的大脑变的简单。所以，我们不是简单的会用就可以，我们还需要了解这个工具是如何工作的，如何为我们提供便利的。ok，下面进入正题，我们从问题开始……...

JavaWeb开发分享：urlrewriter

在Java Web开发中，有时候为了提高安全性(隐藏技术的实现，我们可以通过Url重写可以实现技术的隐藏，可以有效的避免一些参数名、ID等完全暴露在用户面前)或者提高网站的移植性和方便用户使用(用户不用关心你网站的页面的地址变更，后台方法改动的话，可以保证前台的页面地址部分不用改)会采用地址重写功能，将动态地址伪静态。这样还可以优化搜索引擎的抓取。在Java中实现地址重写是通过过滤器常用的forward()和sendRedirect()来实...

javaweb 开发总结五-----servlet开发(一)

一 servlet简介Servlet是sun公司提供的一门用于开发动态web资源的技术Sun公司在其API 中提供了一个Servlet接口，用户若想开发一个动态web资源(及开发一个Java程序向浏览器输出数据)，需要完成以下2个步骤：1.编写一个java类，实现servlet接口2.把开发好的java类部署到web服务器中按照一种约定俗成的称呼习惯，通常我们也把实现了servlet接口的java程序，称之为servlet二 Servlet的运行过程Servlet程序是由web服务器调用，web服务器...

javaWeb中servlet开发(5)——WEB开发模式：Mode I与Mode II【代码】【图】

1、servlet开发2、model I模式客户端通过访问JSP，调用里面的javabean，而通过javabean调用处理数据库的操作，javabean中有专门处理数据库的操作，数据库主要以DAO为主，出去了数据库外也包含业务处理。 3、model II 开发模式servlet特点：可以接收用户的请求，还可以调用Java程序，由于本身就是以Java程序运行的，所以肯定要比jsp性能高，而且安全性能高。最终，servlet所有的操作内容都有交个jsp显示，这样一来，servlet缺点就避...

OSCHina技术导向：Java轻量web开发框架——JFinal【图】

JFinal 是基于 Java 语言的极速 WEB + ORM 框架，其核心设计目标是开发迅速、代码量少、学习简单、功能强大、轻量级、易扩展、Restful。在拥有Java语言所有优势的同时再拥有ruby、python、php等动态语言的开发效率！为您节约更多时间，去陪恋人、家人和朋友 :)JFinal有如下主要特点：MVC架构，设计精巧，使用简单遵循COC原则，零配置，无xml独创Db + Record模式，灵活便利ActiveRecord支持，使数据库开发极致快速自动加载修改后的j...

JAVAWEB开发之Session的追踪创建和销毁、JSP具体解释（指令，标签，内置对象，动作即转发和包括）、JavaBean及内省技术以及EL表达式获取内容的使用【图】

Session的追踪技术已知Session是利用cookie机制的server端技术。当client第一次訪问资源时假设调用request.getSession() 就会在server端创建一个由浏览器独享的session空间，并分配一个唯一且名称为JSESSIONID的cookie发送到浏览器端，假设浏览器没有禁用cookie的话，当浏览器再次訪问项目中的Servlet程序时会将JSESSIONID带着。这时JSESSIONID就像唯一的一把钥匙开启server端相应的session空间。进而获取到session中的内容（Se...

集成框架 javaweb开发平台ssmy_m(生成代码) java struts2 mybatis spring maven jquery【图】

网页地址 http://blog.csdn.net/lpy3654321/article/details/31841573 项目设想,在项目开发中,我们的开发者大多数时间都在反复开发相同的keyword,相同的语法. 但就在这种情况下还会常常发生语法的错误,并且每一个开发者的代码风格不同. 其它人员阅读困难.新人的学习成本也会添加. 这些问题会浪费非常多时间,也会影响到开发者的心情,和程序质量. 由这些问题我想的解决方法是 <代码生成工具> . 代码生成能够解决上述...

JAVA - 技术教程分类

Java 教程 Java 简介 Java 开发环境配置 Java 基础语法 Java 对象和类 Java 基本数据类型 Java 变量类型 Java 修饰符 Java 运算符 Java 循环结构 Java 条件语句 Java switch case Java Number & Math 类 Java Character 类 Java String 类 Java StringBuffer Java 数组 Java 日期时间 Java 方法 Java Stream、File、IO Java Scanner 类 Java 异常处理 Java 继承 Java Override/Overload Java 多态 Java 抽象类 Java 封装 Java 接口 Java 枚举 Java 包(package) Java 数据结构 Java 集合框架 Java ArrayList Java LinkedList Java HashSet Java HashMap Java Iterator Java Object Java 泛型 Java 序列化 Java 网络编程 Java 多线程编程 Java Applet 基础 Java 文档注释 Java 实例 Java 8 新特性 Java MySQL 连接 Java 9 新特性 Java 测验 java 全部

JAVA - 最热教程

Java在运行项目时候，点击右键的弹框，...nacos配置中心超时问题：java.net.Conn...Java的设计模式（7）— 生产者-消费者模...基于DOM4j和POI实现的XML文件转换为XLS...如何在Java中创建一些变量类型别名使用java8的Stream统计字符串数组中每一...idea插件篇之java内存分析工具(JProfil...cannot cast 'java.lang.Integer' to '...java – Bootstrap.properties中Spring...Java8利用stream流实现数字排序和中文排...

首页 / JAVA / Java Web开发模式

Java Web开发模式

内容导读

内容图文

内容总结

内容备注

内容手机端

【Java Web开发模式】教程文章相关的互联网学习教程文章

Java Web开发模式【代码】【图】

java web开发入门一（servlet和jsp）基于eclispe【代码】

JAVA web开发模式【图】

java web开发高并发处理

高效 Java Web 开发框架 JessMA v3.5.1 正式发布【图】

分享Java web 开发必游之路

学习Java Web(二)：开发SpringMVC项目

java_WEB开发防刷新【代码】【图】

Java Web开发基础（3）-JSTL【图】

JavaWeb开发分享：urlrewriter

javaweb 开发总结五-----servlet开发(一)

javaWeb中servlet开发(5)——WEB开发模式：Mode I与Mode II【代码】【图】

OSCHina技术导向：Java轻量web开发框架——JFinal【图】

JAVAWEB开发之Session的追踪创建和销毁、JSP具体解释（指令，标签，内置对象，动作即转发和包括）、JavaBean及内省技术以及EL表达式获取内容的使用【图】

集成框架 javaweb开发平台ssmy_m(生成代码) java struts2 mybatis spring maven jquery【图】

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程