java web开发入门

时间 2019-11-05

标签 java web 开发入门栏目 Java 繁體版

原文原文链接

servlet

用java语言开发动态资源网站的技术，在doGet方法中拼接显示html，在doPost方法中提交数据。相似于.net的ashx技术。html

servlet生成的class文件存放在tomcat中webapps目录下。java

1.开发一个servlet步骤：mysql

　　1）在src下新建包并编写java类，继承HttpServlet类程序员

　　2）重写doGet和doPost方法web

package com.eggtwo.boss;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/test")
public class TestServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    public TestServlet() {
        super();
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        response.getWriter().append("Served at: ").append(request.getContextPath());
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }

}

2.servlet的生命周期spring

构造方法：建立servlet对象的时候调用。默认状况下，第一次访问servlet的时候建立servlet对象只调用1次。证实servlet对象在tomcat是单实例的。sql

init方法：建立完servlet对象的时候调用。只调用1次。数据库

service方法：每次发出请求时调用。调用n次。express

destroy方法：销毁servlet对象的时候调用。中止服务器或者从新部署web应用时销毁servlet对象。只调用1次。apache

JSP

1.特色：

用java语言+html开发动态网站的技术。jsp就是servlet（）。

相似于.net的webform，jsp页面能够java语言和html混合写。

tomcat的work目录存放jsp运行的临时文件（.java和.class文件），在运行jsp页面时动态生成并执行。

访问方式：http://localhost:8080/javaweb/hello.jsp

2.建立方式：

在WebRoot下建立jsp页面。

<%@page import="java.util.Date"%>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
<%
out.write("hello");
Date dt=new Date();
String s=dt.toLocaleString();
%>
<h3><%=s %></h3>
</body>
</html>

3.生命周期：

1）翻译： jsp->java文件

2）编译： java文件->class文件（servlet程序）

3）构造方法（第1次访问）

4）init方法（第1次访问）：_jspInit()

5）service方法：_jspService()

6）destroy方法：_jspDestroy()

4.jsp语法

4.1jsp表达式：

语法：<%=变量或表达式%>

做用：向浏览器输出变量的值或表达式计算的结果

注意：

1）表达式的原理就是翻译成out.print(“变量” );经过该方法向浏览器写出内容

2）表达式后面不须要带分号结束。

4.2jsp脚本

语法：<% java代码 %>

做用：执行java代码

注意：原理把脚本中java代码原封不动拷贝到_jspService方法中执行，不能声明方法

4.3jsp的声明

语法：<%! 变量或方法 %>

做用：声明jsp的变量或方法

注意:

1）变量翻译成成员变量，方法翻译成成员方法。

4.4jsp的注释

语法： <%-- jsp注释 --%>

注意;

1)html的注释会被翻译和执行。而jsp的注释不能被翻译和执行。

4.5jsp指令

include指令：

做用：在当前页面用于包含其余页面，相似于.net mvc中的分布视图

语法： <%@include file="common/header.jsp"%>

注意：

1）原理是把被包含的页面（header.jsp）的内容翻译到包含页面(index.jsp)中,合并成翻译成一个java源文件，再编译运行！！，这种包含叫静态包含（源码包含）

2）若是使用静态包含，被包含页面中不须要出现全局的html标签了！！！（如html、head、 body）

page指令：

做用：告诉tomcat服务器如何翻译jsp文件

<%@ page 
    language="java"   --告诉服务器使用什么动态语言来翻译jsp文件
    import="java.util.*" --告诉服务器java文件使用什么包导入包，多个包之间用逗号分割
    pageEncoding="utf-8"  --告诉服务器使用什么编码翻译jsp文件（成java文件）
    contentType="text/html; charset=utf-8" 服务器发送浏览器的数据类型和内容编码，注意：在开发工具中，之后只须要设置pageEncoding便可解决中文乱码问题
    errorPage="error.jsp"  --指定当前jsp页面的错误处理页面。
    isErrorPage="false" --指定当前页面是否为错误处理页面。false，不是错误处理页面，则不能使用exception内置对象；true，是错误处理页面，可使用exception内置对象。
    buffer="8kb" --jsp页面的缓存区大小
    session="true" --是否开启session功能。false，不能用session内置对象；true，可使用session内置对象。
    isELIgnored="false" --是否忽略EL表达式
%>

配置全局的错误处理页面：

在web.xml中的web-app节点下配置：

<!-- 全局错误处理页面配置 -->
  <error-page>
      <error-code>500</error-code>
      <location>/common/500.jsp</location>
  </error-page>
  <error-page>
      <error-code>404</error-code>
      <location>/common/404.html</location>
  </error-page>

5.jsp内置对象

JSP内置对象(9个内置对象):
1.pageContext 　　javax.servlet.jsp.PageContext JSP的页面容器
2.request 　　　　 javax.servlet.http.HttpServletrequest 获取用户的请求信息
3.response 　　 javax.servlet.http.HttpServletResponse 服务器向客户端的回应信息
4.session 　　 javax.servlet.http.HttpSession 用来保存每个用户的信息
5.application 　　 javax.servlet.ServletContext 表示全部用户的共享信息
6.config 　　 javax.servlet.ServletConfig 服务器配置信息，能够取得初始化参数
7.out　　 javax.servlet.jsp.jspWriter 页面输出
8.page　　　　 (java.lang.object)
9.exception java.lang.Throwable

4个域对象的范围:用于共享数据（设置、获取、删除）
page(pageContext):只在当前jsp页面中有效，跳转以后无效。
request:只在一次请求中有效，服务器跳转(转发)以后有效。客户端跳无效
session:在一次会话中有效。服务器跳转、客户端跳转都有效。网页关闭从新打开无效
application:在整个服务器上保存，全部用户均可使用。重启服务器后无效

<%
pageContext.setAttribute("age", 18);
pageContext.setAttribute("tom", 11,pageContext.REQUEST_SCOPE);
request.setAttribute("name","jack");
session.setAttribute("lily", 12);
application.setAttribute("全局",12);

%>
<h1>${name}</h1>
<h1>${tom}</h1>
<h1>${age}</h1>
<h1>${lily}</h1>
<h1>${全局}</h1>

域对象保存值，取值，删除的方法

//设置值
pageContext.setAttribute("age", 18);
//取值
Object obj=pageContext.getAttribute("age");
if(obj==null){
    out.write("已删除");
}else{    
    //数字直接试用out.write输出会乱码
    int age=Integer.parseInt(obj.toString());
    out.write(Integer.toString(age));
    //或者
    //out.write(obj.toString());
}
out.write("<br/>");
pageContext.removeAttribute("age");
Object obj1=pageContext.getAttribute("age");
if(obj1==null){
    out.write("已删除");
}else{
    out.write(obj1.toString());
}

注意：若是设置过多的application属性范围会影响服务器性能。
pageContext.PAGE_SCOPE
pageContext.REQUEST_SCOPE
pageContext.SESSION_SCOPE
pageContext.APPLICATION_SCOPE
pageContext.setAttribute("name", "liuyang", pageContext.APPLICATION_SCOPE);

6.EL表达式

6.1 做用

jsp的核心语法： jsp表达式 <%=%>和 jsp脚本<% %>。

之后开发jsp的原则：尽可能在jsp页面中少写甚至不写java代码。

使用EL表达式替换掉jsp表达式

EL表达式做用：向浏览器输出域对象中的变量值或表达式计算的结果！！！

语法： ${变量或表达式}

6.2EL语法

1）输出基本数据类型变量

1.1 从四个域获取

${name}

1.2 指定域获取

${pageScope.name}

1.3 输出对象属性：student.name 注意：.name 至关于 getName()方法，其中name和Name要对应

域范围： pageScoep / requestScope / sessionScope / applicationScope

2）处理集合${studentList[0].name}

3)表达式计算 ${10+1}

7.jsp标签

7.1 jsp标签做用：

替换jsp脚本

7.2 Jsp标签分类：

1）内置标签（动做标签）：不须要在jsp页面导入标签

2）jstl标签：须要在jsp页面中导入标签

3）自定义标签：开发者自行定义，须要在jsp页面导入标签

内置标签（动做标签）：

转发标签： <jsp:forward />

参数标签： <jsp:pararm/>

例如：内部跳转到second.jsp并带上参数name=jack

<jsp:forward page="second.jsp">
<jsp:param value="name" name="jack"/>
</jsp:forward>

等同于

request.getRequestDispatcher("second.jsp?name=jack").forward(request, response);

包含标签： <jsp:include/>

<%@include file="common.jsp" %>
<jsp:include page="comm.jsp">
<jsp:param value="name" name="jack"/>
</jsp:include>

静态包含语法： <%@inclue file="被包含的页面"%>

动态包含语法：　<jsp:include page="被包含的页面">

静态包含：先合并再翻译

动态包含：先翻译再合并

7.3 JSTL标签

JSTL (全名：java standard tag libarary - java标准标签库 )

五套标签库：

1.核心标签库（c标签库）每天用

2.国际化标签（fmt标签库）

3.EL函数库（fn函数库）

4.xml标签库（x标签库）

5.sql标签库（sql标签库）

使用JSTL标签步骤
1） Eclispe须要导入jstl支持的jar包（标签背后隐藏的java代码）注意：MyEclispe使用javaee5.0的项目自动导入jstl支持jar包

eclispe导入方式：将standard.jar和jstl.jar文件拷贝到工程的\WEB-INF\lib\下，而后build path
2）使用taglib指令导入标签库 <%@taglib uri="tld文件的uri名称" prefix="简写" %>

例如：在jsp页面导入核心标签库：

  <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

3）在jsp中使用jstl标签

保存数据： <c:set></c:set>

 <%--
 set标签：保存值到域中
 var:值的名称
 value：值
 scope:值的范围，page,request,session,application
  --%>
<c:set var="sex" value="man" scope="request"></c:set>

获取数据：<c:out value=""></c:out>

<%--
out标签：获取域中设置的数据
default：当value为null时，使用默认值
escapeXml:是否对value进行转义，false不转义，true转义
 --%>
<c:out value="${sex}" default="<h1>默认值</h1>" escapeXml="true"></c:out>

单条件判断： <c:if test=""></c:if>

<%--if标签：单条件判断 --%>
<c:if test="${5>3}">

多条件判断：

<c:choose></c:choose>

<c:when test=""></c:when>

<c:otherwise></c:otherwise>

<c:set var="score" value="80"></c:set>
<c:choose>
    <c:when test="${score>90}">
    优秀
    </c:when>
    <c:when test="${score<=90&&score>60}">
    良好
    </c:when>
    <c:otherwise>
    差
    </c:otherwise>
</c:choose>

循环数据：

<c:forEach></c:forEach>

<%
ArrayList<String> list=new ArrayList<String>();
 list.add("tom");
 list.add("jack");
 list.add("jack");
 pageContext.setAttribute("list", list);
%>
<%--forEach循环 
begin:从哪一个元素开始，默认从0开始
end:到哪一个元素结束
step:每次的增量
items：要遍历的数据
var：每一个元素的名称
varStatus:正在遍历的元素的状态对象，count属性默认从1开始
--%>
<c:forEach begin="0" end="2" step="1" items="${list}" var="names" varStatus="varSta">
<h4>顺序：${varSta.count}，${names}</h4>
</c:forEach>

<c:forTokens items="" delims="" var=""></c:forTokens>

<%
String sps="a-b-c";
pageContext.setAttribute("sps",sps);
%>
<c:forTokens items="${sps}" delims="-" var="ss">
<h5>${ss}</h5>
</c:forTokens>

重定向：<c:redirect url=""></c:redirect>

<c:redirect url="http://www.baidu.com"> </c:redirect>

7.4 自定义标签

开发步骤：

编写一个普通的java类，继承SimpleTagSupport类，叫标签处理器类

public class ShowIpTag extends SimpleTagSupport {
    
    @Override
    public void doTag() throws JspException, IOException {
        // 向浏览器输出客户的ip地址
        PageContext pageContext = (PageContext) getJspContext();

        HttpServletRequest request = (HttpServletRequest) pageContext.getRequest();

        String ip = request.getRemoteHost();

        JspWriter out = pageContext.getOut();

        out.write("使用自定义标签输出客户IP地址：" + ip);

    }

}

2）在web项目的WEB-INF目录下创建eggtwo.tld文件，这个tld叫标签库的声明文件。（参考核心标签库的tld文件）

<?xml version="1.0" encoding="UTF-8" ?>

<taglib xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"
    version="2.1">
    <!-- 标签库版本 -->
    <tlib-version>1.1</tlib-version>
    <!-- 标签库前缀版本 -->
    <short-name>eggtwo</short-name>
    <!--tld文件的惟一标记，完整的uri -->
    <uri>http://tag.eggtwo.com</uri>
    <tag>
        <!--标签名称tld文件的惟一标记 -->
        <name>showIp</name>
        <!--标签处理器类的全称（包名+类名） -->
        <tag-class>com.eggtwo.boss.ShowIpTag</tag-class>
        <!--输出内容的格式 -->
        <body-content>scriptless</body-content>

    </tag>
</taglib>

3）在jsp页面的头部导入自定义标签库

 <%@taglib prefix="eggtwo" uri="http://tag.eggtwo.com" %>

4）在jsp中使用自定义标签

<eggtwo:showIp></eggtwo:showIp>

JavaBean

JavaBean, 咖啡豆。 JavaBean是一种开发规范，能够说是一种技术。

JavaBean就是一个普通的java类。只有符合如下规定才能称之为javabean：

1）必须提供无参数的构造方法

2）类中属性都必须私有化(private)

3）该类提供公开的getter 和 setter方法

getName() setName(String name)

注意： boolean类型的get方法名称叫 isXXX()方法 public boolean isAcitve()

JavaBean的做用：用于封装数据，保存数据。

访问javabean只能使用getter和setter方法

JavaBean的使用场景：

1）项目中用到实体对象（entity）符合javabean规范

2）EL表达式访问对象属性。${student.name} 调用getName()方法，符合javabean规范。

3）jsp标签中的属性赋值。 setNum（Integer num）。符合javabean规范。

4）jsp页面中使用javabean。符合javabean规范

mysql

struts

struts是对servlet的封装

1.开发步骤

1.下载struts 开发库：http://struts.apache.org 下载点击下载：struts-*-all.zip版本，使用2.3版本

2.在项目lib下面导入struts必须的包，而后build path

commons-fileupload-1.2.2.jar 【文件上传相关包】
commons-io-2.0.1.jar
struts2-core-2.3.4.1.jar 【struts2核心功能包】
xwork-core-2.3.4.1.jar 【Xwork核心包】
ognl-3.0.5.jar 【Ognl表达式功能支持表】
commons-lang3-3.1.jar 【struts对java.lang包的扩展】
freemarker-2.3.19.jar 【struts的标签模板库jar文件】
javassist-3.11.0.GA.jar 【struts对字节码的处理相关jar】

3.配置web.xml

  <!-- 引入struts核心过滤器 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

4.开发action

在src下面建立struts的action，继承ActionSupport

//开发action： 处理请求
public class HelloAction extends ActionSupport {
    
    // 处理请求
    public String execute() throws Exception {
        System.out.println("访问到了action，正在处理请求");
        System.out.println("调用service");
        return "success";
    }
}

5.在src下面添加struts.xml文件（能够在struts包中搜索）

一个struts.xml中能够有多个package，可是package的名称不能重复

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
          "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
          "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <!-- name任意名称，extends固定写法 -->
    <package name="mystruts" extends="struts-default">
        <!-- name：浏览器要访问的名称，class：编写的action全称，method：action下面的方法 -->
        <action name="hello" class="com.eggtwo.action.HelloAction"
            method="execute">
            <!-- name:返回值， 跳转地址 -->
            <result name="success">/index.jsp</result>
        </action>
    </package>
</struts>

5.1struts.xml的第二种配置方式：

在src下面添加总的struts.xml文件，而后在总文件中引用各个包中的struts.xml文件

总struts.xml文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
          "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
          "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
  <!-- 总配置文件：引用其余包中的独立的配置文件 -->
    <include file="com/eggtwo/action/struts.xml"></include>
</struts>

包中的struts.xml文件：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
          "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
          "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <!-- name任意名称，extends:继承的类 -->
    <package name=com.eggtwo.action namespace="/" extends="struts-default" abstract="false">
        <!-- name：浏览器要访问的名称，class：编写的action全称，method：action下面的方法 -->
        <action name="execute" class="com.eggtwo.action.HelloAction" method="execute">
            <!-- name:返回值， 跳转地址 -->
            <result name="success" >/index.jsp</result>
        </action>
        
        <action name="login" class="com.eggtwo.action.LoginAction" method="login">
            <!-- name:返回值， 跳转地址 -->
            <result name="success" >/login.jsp</result>
        </action>
    </package>
</struts>

View Code

项目结构：

2.执行流程

服务器启动：

1. 加载项目web.xml

2. 建立Struts核心过滤器对象，执行filter -> init()

struts-default.xml, 核心功能的初始化

　　 struts-plugin.xml, struts相关插件

　　 struts.xml 用户编写的配置文件

访问：

3. 用户访问Action, 服务器根据访问路径名称，找对应的aciton配置, 建立action对象

4. 执行默认拦截器栈中定义的18个拦截器

5. 执行action的业务处理方法

Hibernate

1.开发流程

项目配置好后的结构：

1.下载源码：版本：hibernate-distribution-3.6.0.Final

2.引入hibernate须要的开发包（3.6版本），若是没有引用成功，在jar包上右键执行：add as library

3.编写实体对象及对象的映射xml文件

实体类：

package com.eggtwo.test;

import java.util.Date;

public class Student {
    private int  id;
    private String name;
    private int age;
    private Date birthday;
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }



}

View Code

数据库表结构：

映射xml文件：（放在包下面）

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.eggtwo.test">

    <class name="Student" table="student">
        <!-- 主键 ，映射-->
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <!-- 非主键，映射 -->
        <property name="name" column="name"></property>
        <property name="age" column="age"></property>
        <property name="birthday" column="birthday"></property>
    </class>

</hibernate-mapping>

View Code

4.配置主配置文件：src/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>
        <!-- 数据库链接配置 -->
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql:///test</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">123456</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>

        <property name="hibernate.show_sql">true</property>

        <!-- 加载全部映射 -->
        <mapping resource="com/eggtwo/test/Student.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

View Code

5.测试添加一条数据：

package com.eggtwo.test;
import java.util.Date;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

public class TestApp {
    @Test
    public void testHello() throws Exception {
        // 建立对象：主键自增加
        Student s = new Student();
        s.setAge(12);
        s.setName("班长");
        s.setBirthday(new Date());

        // 获取加载配置文件的管理类对象
        Configuration config = new Configuration();
        config.configure();  // 默认加载src/hibenrate.cfg.xml文件
        // 建立session的工厂对象
        SessionFactory sf = config.buildSessionFactory();
        // 建立session (表明一个会话，与数据库链接的会话)
        Session session = sf.openSession();
        // 开启事务
        Transaction tx = session.beginTransaction();
        //保存-数据库
        session.save(s);
        // 提交事务
        tx.commit();
        System.out.println("save success");
        // 关闭
        session.close();
        sf.close();
    }

}

View Code

2.映射详解

spring

ssh=struts(controller)+spring(service)+hibernate(dao)

1.spring简介

Spring框架，能够解决对象建立以及对象之间依赖关系的一种框架。

且能够和其余框架一块儿使用；Spring与Struts, Spring与hibernate

(起到整合（粘合）做用的一个框架)

Spring提供了一站式解决方案：

1） Spring Core spring的核心功能： IOC容器, 解决对象建立及依赖关系

2） Spring Web Spring对web模块的支持。

-à 能够与struts整合,让struts的action建立交给spring

-à spring mvc模式

3） Spring DAO Spring 对jdbc操做的支持【JdbcTemplate模板工具类】

4） Spring ORM spring对orm的支持：

à 既能够与hibernate整合，【session】

à 也可使用spring的对hibernate操做的封装

5）Spring AOP 切面编程

6）SpringEE spring 对javaEE其余模块的支持

2.spring开发步骤

1.下载引用开发包

spring各个版本中：

在3.0如下的版本，源码有spring中相关的全部包【spring功能 + 依赖包】

如2.5版本；

在3.0以上的版本，源码中只有spring的核心功能包【没有依赖包】

(若是要用依赖包，须要单独下载！)

源码, jar文件：spring-framework-3.2.5.RELEASE

commons-logging-1.1.3.jar 日志

spring-beans-3.2.5.RELEASE.jar bean节点

spring-context-3.2.5.RELEASE.jar spring上下文节点

spring-core-3.2.5.RELEASE.jar spring核心功能

spring-expression-3.2.5.RELEASE.jar spring表达式相关表

以上是必须引入的5个jar文件！

2.在src下面的包中建立Student对象：

package com.eggtwo.test;

public class Student {
    private int age;
    private String name;
public Student(){
    super();
    System.out.println("调用了student的构造函数");
}
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void init_student()
    {
        System.out.println("初始化了对象");
    }
    public void destroy_student()
    {
        System.out.println("销毁了对象");
    }
}

View Code

3.在src下面的包中引入核心配置文件： applicationContext.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--
      1) 对象建立： 单例/多例
          scope="singleton", 默认值， 即 默认是单例    【service/dao/工具类】
       scope="prototype", 多例；                 【Action对象】
      2) 何时建立?
            scope="prototype"  在用到对象的时候，才建立对象。
         scope="singleton"  在启动(容器初始化以前)， 就已经建立了bean，且整个应用只有一个。
      3)是否延迟建立
            lazy-init="false"  默认为false,  不延迟建立，即在启动时候就建立对象
            lazy-init="true"   延迟初始化， 在用到对象的时候才建立对象（只对单例有效）
      4) 建立对象以后，初始化/销毁
            init-method="init_student"       【对应对象的init_student方法，在对象建立爱以后执行 】
         destroy-method="destroy_student"  【在调用容器对象的destriy方法时候执行，(容器用实现类)】

-->
    <bean id="student" class="com.eggtwo.test.Student" scope="prototype" lazy-init="false"  init-method="init_student"  destroy-method="destroy_student"></bean>

</beans>

4.使用pring建立对象：getBean中的参数是xml中设置的id

package com.eggtwo.test;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class APPTest {
    @Test
    public  void  test(){
        // 获得IOC容器对象  【用实现类，由于要调用销毁的方法】
        System.out.println("-----容器建立前-----");
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("com/eggtwo/test/applicationContext.xml");
        System.out.println("-----容器建立完成-----");

        // 从容器中获取bean
        Student student1 = (Student) ac.getBean("student");
        Student student2 = (Student) ac.getBean("student");

        System.out.println(student1);
        System.out.println(student2);

        // 销毁容器对象
        ac.destroy();
    }
}

2.spring IOC容器的配置

1.对象的建立方式

SpringIOC容器，是spring核心内容。

做用：建立对象 & 处理对象的依赖关系

IOC容器建立对象：

建立对象, 有几种方式：

1）调用无参数构造器

2）带参数构造器

3）工厂建立对象

工厂类，静态方法建立对象

工厂类，非静态方法建立对象

<!-- ###############对象建立############### -->
    
    <!-- 1. 默认无参数构造器 
    <bean id="user1" class="cn.itcast.b_create_obj.User"></bean>
    -->
    
    <!-- 2. 带参数构造器 -->
    <bean id="user2" class="cn.itcast.b_create_obj.User">
        <constructor-arg index="0" type="int" value="100"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" value="Jack"></constructor-arg>
    </bean>
    
    <!-- 定义一个字符串，值是"Jack" ;  String s = new String("jack")-->
    <bean id="str" class="java.lang.String">
        <constructor-arg value="Jacks"></constructor-arg>
    </bean>
    <bean id="user3" class="cn.itcast.b_create_obj.User">
        <constructor-arg index="0" type="int" value="100"></constructor-arg>
        <constructor-arg index="1" type="java.lang.String" ref="str"></constructor-arg>
    </bean>
    
    
    <!-- 3. 工厂类建立对象 -->
    <!-- # 3.1 工厂类，实例方法 -->
    <!-- 先建立工厂 -->
    <bean id="factory" class="cn.itcast.b_create_obj.ObjectFactory"></bean>
    <!-- 在建立user对象，用factory方的实例方法 -->
    <bean id="user4" factory-bean="factory" factory-method="getInstance"></bean>
    
    
    <!-- # 3.2 工厂类： 静态方法 -->
    <!-- 
        class 指定的就是工厂类型
        factory-method  必定是工厂里面的“静态方法”
     -->
    <bean id="user" class="cn.itcast.b_create_obj.ObjectFactory" factory-method="getStaticInstance"></bean>

2.对象的依赖关系

Spring中，如何给对象的属性赋值? 【DI, 依赖注入】

1) 经过构造函数

2) 经过set方法给属性注入值

3) p名称空间

4)自动装配(了解)

5) 注解

    <bean id="userDao" class="com.eggtwo.dao.UserDao" ></bean>
    <bean id="userService" class="com.eggtwo.service.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>
    <bean id="userAction" class="com.eggtwo.action.UserAction">
        <property name="userService" ref="userService"></property>
    </bean>

3.spring和strut结合

步骤：

引入jar文件

1）引入struts .jar相关文件

2）spring-core 相关jar文件

3）spring-web 支持jar包

spring-web-3.2.5.RELEASE.jar 【Spring源码】

　　 struts2-spring-plugin-2.3.4.1.jar 【Struts源码】

配置:

4）配置XML

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!-- 引入struts核心过滤器 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 2. spring 配置 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/classes/bean-*.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>


</web-app>

bean.xml 【spring ioc容器配置】

每一个包配置一个bean

<?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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">


    <bean id="userService" class="com.eggtwo.service.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>

</beans>

struts.xml struts路径与action映射配置】

注意：action交给了spring建立，再也不是tomcat建立

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
          "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
          "http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
    <!-- name任意名称，extends:继承的类 -->
    <package name="com.eggtwo.action" namespace="/" extends="struts-default" abstract="false">


        <action name="execute" class="userAction" method="execute">
            <!-- name:返回值， 跳转地址 -->
            <result name="success" >/index.jsp</result>
        </action>

    </package>
</struts>

【核心过滤器：引入struts功能】

【初始化spring的ioc容器】

4.代理模式

静态代理（JDK代理）

动态代理（JDK代理）

CgLib代理

5.Spring 注解实现AOP编程

AOP的实现本质上是代理（动态代理和Cglib代理）

注意：java jdk使用1.8版本，spring的jar包要使用4.2版本以上才可使用AOP功能

开发步骤：

1.引入aop相关jar包

spring-aop-3.2.5.RELEASE.jar [spring3.2.5源码/libs]

aopalliance.jar [spring-framework-2.5.6/lib/aopalliance]

aspectjrt.jar [aspectj-1.8.2/lib]

aspectjweaver.jar [aspectj-1.8.2/lib]

2.bean.xml中引入aop名称空间

3.在bean.xml中开启AOP注解模式

4.新建切面类

package com.eggtwo.aopanno;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component //注解 ioc
@Aspect   //指定当前类为切面类
public class MyAspect {

    @Pointcut("execution(* com.eggtwo.aopanno.UserDao.*(..))")
    public void myPointcut() {
    }

    //执行方法前执行
    @Before("myPointcut()")
    public void begin() {
        System.out.println("开始执行");
    }

    //执行目标方法后执行：（不管目标方法是否出现异常，都会执行）
    @After("myPointcut()")
    public void end() {
        System.out.println("结束执行");
    }

    //执行目标方法后执行：（发生异常不执行）
    @AfterReturning("myPointcut()")
    public void afterReturning() {
        System.out.println("afterReturning");
    }

    //执行目标方法后执行：（发生异常执行）
    @AfterThrowing("myPointcut()")
    public void afterThrowing() {
        System.out.println("afterThrowing");
    }
    //环绕通知：环绕目标方法执行
    @Around("myPointcut()")
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前");
        pjp.proceed();
        System.out.println("环绕后");

    }
}

执行结果顺序：

5.测试

package com.eggtwo.aopanno;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestApp {
    @Test
    public void test() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("com/eggtwo/aopanno/bean.xml");
        UserDao userDao = (UserDao) ac.getBean("userDao");
        System.out.println(userDao.getClass());
        userDao.save();
    }
}

6.Spring XML实现AOP编程

1.引入jar相关开发包（同步骤5.1）

2.引入命名空间（同5.2）

3.aop配置：添加切面类

package com.eggtwo.aopxml;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

public class MyAspect {


    //执行方法前执行
    public void begin() {
        System.out.println("开始执行");
    }

    //执行目标方法后执行：（不管目标方法是否出现异常，都会执行）
    public void end() {
        System.out.println("结束执行");
    }

    //执行目标方法后执行：（发生异常不执行）
    public void afterReturning() {
        System.out.println("afterReturning");
    }

    //执行目标方法后执行：（发生异常执行）
    public void afterThrowing() {
        System.out.println("afterThrowing");
    }

    //环绕通知：环绕目标方法执行
    public void around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前");
        pjp.proceed();
        System.out.println("环绕后");

    }
}

4.配置bean.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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
">
    <!--spring IOC-->
    <bean id="userDao" class="com.eggtwo.aopxml.UserDao"></bean>
    <bean id="myAspect" class="com.eggtwo.aopxml.MyAspect"></bean>


    <!--AOP配置-->
    <aop:config>
        <!-- 定义切面点表达式：指定拦截的方法       -->
        <aop:pointcut id="myPointcut" expression="execution(* com.eggtwo.aopxml.UserDao.*(..))"/>
        <!-- 切面：引用上面配置的切面类-->
        <aop:aspect ref="myAspect">
            <!--<aop:before method="begin" pointcut="execution(* com.eggtwo.aopxml.UserDao.*(..))"/>-->
            <aop:before method="begin" pointcut-ref="myPointcut"/>
            <aop:before method="end" pointcut-ref="myPointcut"/>
        </aop:aspect>
    </aop:config>
</beans>

7.Spring 切入点表达式

做用：指定拦截的方法

8.Spring 事务管理

事务的实现自己是AOP

XML方式实现spring声明式事务

SSH整合

1.引入jar包

Struts 核心jar

Hibernate 核心jar

Spring

Core 核心功能

Web 对web模块支持

Aop aop支持

Orm 对hibernate支持

Jdbc/tx jdbc支持包、事务相关包

2.配置xml

*.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 package="com.eggtwo.entity">

    <class name="Student" table="t_student">
        <id name="id" column="id">
            <generator class="native"></generator>
        </id>
        <!-- 外键映射：多对一 -->
        <many-to-one name="grade" column="gradeId" class="Grade"></many-to-one>
        <property name="name"></property>
        <property name="age"></property>
        <property name="birthday"></property>

    </class>

</hibernate-mapping>

View Code

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!-- 配置spring的OpenSessionInView模式 【目的：JSp页面访问懒加载数据】 -->
    <!-- 注意：访问struts时候须要带上*.action后缀，这样才能访问懒加载数据 -->
    <filter>
        <filter-name>OpenSessionInView</filter-name>
        <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>OpenSessionInView</filter-name>

<!--url请求设置-->
        <url-pattern>*.action</url-pattern>
    </filter-mapping>

    <!-- struts2配置 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- Spring配置 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:bean*.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

View Code

bean.xml

每个包中单独一个bean

<?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"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
          http://www.springframework.org/schema/tx/spring-tx.xsd">

    
    <!-- 全部配置的公共部分 -->
    <!-- 1) 数据源对象: C3P0链接池实例 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql:///test"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
        <property name="initialPoolSize" value="3"></property>
        <property name="maxPoolSize" value="6"></property>
    </bean>

    <!-- 2) SessionFactory实例建立 -->
    <!-- 全部的配置都由spring维护(项目中不须要hibernate.cfg.xml啦) -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <!-- a. 链接池 -->
        <property name="dataSource" ref="dataSource"></property>
        <!-- b. hibernate经常使用配置： 方言、显示sql、自动建表等 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
        <!-- c. 映射配置 -->
        <property name="mappingLocations">
            <list>
                <value>classpath:com/eggtwo/entity/*.hbm.xml</value>
            </list>
        </property>
    </bean>
    
    <!-- 3) 事务配置 -->
    <!-- # 事务管理器 -->
    <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    <!-- # 事务加强 -->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="*" read-only="false"/>
        </tx:attributes>
    </tx:advice>
    <!-- # AOP配置 -->
    <aop:config>
        <aop:pointcut expression="execution(* com.eggtwo.service.*.*(..))" id="pt"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
    </aop:config>
    
</beans>

View Code

struts.xml

<?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>

    <package name="myAction" extends="struts-default">
        <!-- action实例交给spring容器建立 -->
        <!--注意：action的class不能写全称类，要写bean-action中的 bean id-->
        <!-- 这种写法是把action交给tomcat建立，因此类要写全称
        <action name="show" class="com.eggtwo.action.StudentAction" method="execute">
                    <result name="success">/index.jsp</result>
        </action>
        -->
        <action name="show" class="studentAction" method="execute">
            <result name="success">/index.jsp</result>
        </action>

    </package>

</struts>

View Code

3.开发

Entity/Dao/service/action

Entity

package com.eggtwo.entity;

import java.util.Date;

public class Student {
    private int id;
   // private int gradeId;
    private String name;
    private int age;
    private Date birthday;
    private boolean isMan;

    public Grade getGrade() {
        return grade;
    }

    public void setGrade(Grade grade) {
        this.grade = grade;
    }

    private  Grade grade;
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

//    public int getGradeId() {
//        return gradeId;
//    }
//
//    public void setGradeId(int gradeId) {
//        this.gradeId = gradeId;
//    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public boolean isMan() {
        return isMan;
    }

    public void setMan(boolean man) {
        isMan = man;
    }
}

entity实体对象

<?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 package="com.eggtwo.entity">

    <class name="Student" table="t_student">
        <id name="id" column="id">
            <generator class="native"></generator>
        </id>
        <!-- 外键映射：多对一 -->
        <many-to-one name="grade" column="gradeId" class="Grade"></many-to-one>
        <property name="name"></property>
        <property name="age"></property>
        <property name="birthday"></property>

    </class>

</hibernate-mapping>

entity实体对象映射数据库XML文件

Dao

package com.eggtwo.dao;

import com.eggtwo.entity.Student;
import org.hibernate.SessionFactory;
import org.hibernate.classic.Session;
import org.springframework.orm.hibernate4.HibernateTemplate;

import java.io.Serializable;
import java.util.List;

public class StudentDao {
    private SessionFactory sessionFactory;

    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }
    public  void  save(Student student){
        //HibernateTemplate hibernateTemplate=new HibernateTemplate(sessionFactory);
        sessionFactory.getCurrentSession().save(student);
    }
    public  Student findById(Serializable id){
        Student o = (Student) sessionFactory.getCurrentSession().get(Student.class, id);
        return o;
    }
//    public List<Student> findList(){
//        Session currentSession = sessionFactory.getCurrentSession();
//        currentSession.find()
//    }
}

数据访问

Service：事务处理在此包中

package com.eggtwo.service;

import com.eggtwo.dao.StudentDao;
import com.eggtwo.entity.Student;

import java.io.Serializable;

public class StudentService {
    private StudentDao studentDao;

    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
    }
    public  void  save(Student student){
         studentDao.save(student);
    }
    public  Student findById(Serializable id){
        return  studentDao.findById(id);
    }
}

服务

action

package com.eggtwo.action;

import com.eggtwo.entity.Student;
import com.eggtwo.service.StudentService;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import org.omg.PortableServer.REQUEST_PROCESSING_POLICY_ID;

import java.util.Map;

public class StudentAction extends ActionSupport {
    //IOC注入
    private StudentService studentService;

    public void setStudentService(StudentService studentService) {
        this.studentService = studentService;
    }

    @Override
    public String execute() throws Exception {
        int studentId = 2;
        Student student = studentService.findById(studentId);
        Map<String, Object> request = (Map<String, Object>) ActionContext.getContext().get("request");
        request.put("student", student);
        return SUCCESS;
    }
}

action

spring mvc

ssm=spring mvc+spring +mybatis

spring mvc工做流程

1A）客户端发出http请求，只要请求形式符合web.xml文件中配置的*.action的话，就由DispatcherServlet来处理。

1B）DispatcherServlet再将http请求委托给映射器的对象来将http请求交给对应的Action来处理

2）映射器根据客户的http请求，再对比<bean name="/hello.action若是匹配正确，再将http请求交给程序员写的Action

3）执行Action中的业务方法，最终返回一个名叫ModelAndView的对象，其中封装了向视图发送的数据和视图的逻辑名

4）ModelAndView对象随着响应到到DispatcherServlet中了

5）这时DispatcherServlet收到了ModelAndView对象，它也不知道视图逻辑名是何意，又得委托一个名叫视图解析器的对象去具体解析ModelAndView对象中的内容

6）将视图解析器解析后的内容，再次交由DispatcherServlet核心控制器，这时核心控制器再将请求转发到具体的视图页面，取出数据，再显示给用户

XML实现spring mvc

开发步骤：

注意：使用的spring framework版本是：4.2.5

1.引入jar包：

spring核心包

commons-logging-1.1.3.jar
spring-beans-4.2.5.RELEASE.jar
spring-context-4.2.5.RELEASE.jar
spring-core-4.2.5.RELEASE.jar
spring-expression-4.2.5.RELEASE.jar

spring mvc包

spring-web-4.2.5.RELEASE.jar
spring-webmvc-4.2.5.RELEASE.jar

2.xml配置

web.xml配置

配置spring mvc核心控制器

解决提交表单中文乱码

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!-- 注册springmvc核心控制器-->
    <servlet>
        <!--servlet-name的值对应一个文件：/WEB-INF/DispatcherServlet-servlet.xml   -->
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <!-- 指定application.xml文件 -->
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>*.action</url-pattern>
    </servlet-mapping>


    <!--spring编码过滤器：解决POST提交中文乱码问题-->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>


</web-app>

View Code

springmvc.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
          http://www.springframework.org/schema/tx/spring-tx.xsd
          http://www.springframework.org/schema/mvc
           http://www.springframework.org/schema/tx/spring-mvc.xsd

">

    <!-- 1.注册Action(必须配置) -->
    <bean name="/hello.action" class="com.eggtwo.action.HelloController"></bean>

    <!--2.映射器：若是将bean标签的name属性值做为请求URL.此标签能够省略-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>

    <!--3.适配器：实现了Controller接口的适配器，默承认省略-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"></bean>

    <!--4.视图解析器-->
    <!--
        若是Action中书写的是视图逻辑名称，那么视图解析器就必须配置
        若是Action中书写的是视图真实名称，那么视图解析器就不能配置
    -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 路径前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!-- 路径后缀 -->
        <property name="suffix" value=".jsp"/>
        <!-- 前缀+视图逻辑名+后缀=真实路径 -->
    </bean>
</beans>

View Code

3.编写Action

package com.eggtwo.action;


import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.annotation.Annotation;


public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.addObject("message", "这是个人第二个springmvc应用程序，视图使用逻辑名");

        //原来封装视图的真实路径
     // modelAndView.setViewName("/WEB-INF/jsp/success.jsp");

        String name = request.getParameter("name");//获取表单提交的数据
        System.out.println("姓名:"+name);

        //如今封装视图的逻辑名称
        modelAndView.setViewName("success");

        return modelAndView;
    }

}

View Code

注解实现spring mvc

解决的问题：

1.一个controller中放置多个action

2.获取get/post请求的参数(action接收的string类型的date参数怎么转成date)

3.限定action只能接收一种请求方式（get/post）

4.解决表单提交的中文乱码

5.在action中获取request/response

6.在action中重定向

7.action返回值类型（返回html、string、json、file等等）

8.在action中获取request

1.引入jar包：

spring核心包

commons-logging-1.1.3.jar
spring-beans-4.2.5.RELEASE.jar
spring-context-4.2.5.RELEASE.jar
spring-core-4.2.5.RELEASE.jar
spring-expression-4.2.5.RELEASE.jar

spring aop包(注解会使用到aop)

aopalliance.jar
aspectjrt.jar
aspectjweaver.jar
spring-aop-4.2.5.RELEASE.jar

spring mvc包

spring-web-4.2.5.RELEASE.jar
spring-webmvc-4.2.5.RELEASE.jar

2.配置XML：

web.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <!-- 注册springmvc核心控制器-->
    <servlet>
        <!--servlet-name的值对应一个文件：/WEB-INF/DispatcherServlet-servlet.xml   -->
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <!-- 指定application.xml文件 -->
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring_annotation.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>*.action</url-pattern>
    </servlet-mapping>


    <!--spring编码过滤器：解决POST提交中文乱码问题-->
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>




</web-app>

View Code

spring mvc 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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/context
         http://www.springframework.org/schema/context/spring-context.xsd
         http://www.springframework.org/schema/aop
         http://www.springframework.org/schema/aop/spring-aop.xsd
         http://www.springframework.org/schema/tx
          http://www.springframework.org/schema/tx/spring-tx.xsd
          http://www.springframework.org/schema/mvc
           http://www.springframework.org/schema/tx/spring-mvc.xsd

">
    <!--让spring ioc去扫描具体包下的全部具备注解@Controller的类-->
    <context:component-scan base-package="com.eggtwo.action"></context:component-scan>

    <!--注解映射器：可省略-->
    <bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"></bean>


    <!--视图解析器-->
    <!--
        若是Action中书写的是视图逻辑名称，那么视图解析器就必须配置
        若是Action中书写的是视图真实名称，那么视图解析器就不能配置
    -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 路径前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!-- 路径后缀 -->
        <property name="suffix" value=".jsp"/>
        <!-- 前缀+视图逻辑名+后缀=真实路径 -->
    </bean>
</beans>

View Code

3.开发controller 和action：

package com.eggtwo.action;

import com.eggtwo.entity.Student;
import com.sun.org.apache.regexp.internal.RE;
import org.springframework.beans.propertyeditors.CustomDateEditor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.ServletRequestDataBinder;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.context.request.WebRequest;

import javax.servlet.http.HttpServletRequest;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;


/**
 * 此控制器是单例模式，构造函数只执行一次
 * 注解控制器
 */
@Controller
@RequestMapping(value = "/anno")
public class AnnotationController {

    public AnnotationController() {
        System.out.println("AnnotationController()");
    }

    @RequestMapping(value = "/login.action")
    public String login(Model model) {
        model.addAttribute("message", "第一个注解实现的spring mvc login");
        return "success";//逻辑名称，须要配置视图解析器
        //return "/WEB-INF/jsp/success.jsp";

    }

    /**
     * 设置请求的url,接收参数的方式，请求的方式（get/post）(默认get/post请求都支持)
     */
    @RequestMapping(value = "/register1.action", method = {RequestMethod.POST, RequestMethod.GET})
    public String register1(Model model, String name, int age, boolean man) {

        model.addAttribute("message", "注册成功");
        return "success";
        // return "/WEB-INF/jsp/success.jsp";

    }

    /**
     * 请求url中的.action能够省略
     */
    @RequestMapping(value = "/register", method = RequestMethod.POST)
    public String register(Model model, Student student) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");

        System.out.println(student.getBirthday());
        model.addAttribute("message", "注册成功");
        model.addAttribute("student", student);

        return "success";
        // return "/WEB-INF/jsp/success.jsp";

    }

    /**
     * 日期类型转换器
     *
     * @param binder
     */
    @InitBinder
    public void initBinder(WebDataBinder binder) {
        //设置什么类型的时间格式能够转
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        dateFormat.setLenient(false);
        binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));//true:容许为空, false:不容许为空
    }
}

View Code

3.1action向view视图(jsp页面传值)

   @RequestMapping(value = "/register", method = RequestMethod.POST)
    public String register(Model model, Student student) {     
        model.addAttribute("message", "注册成功");
        model.addAttribute("student", student);
        return "success";   

    }

3.2指定action加载返回的视图（jsp页面）

指定物理视图名称：

return "/WEB-INF/jsp/success.jsp";

指定逻辑视图名称：

 return "success";

逻辑视图须要在spring mvc文件配置视图解析器

<!--视图解析器-->
    <!--
        若是Action中书写的是视图逻辑名称，那么视图解析器就必须配置
        若是Action中书写的是视图真实名称，那么视图解析器就不能配置
    -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 路径前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!-- 路径后缀 -->
        <property name="suffix" value=".jsp"/>
        <!-- 前缀+视图逻辑名+后缀=真实路径 -->
    </bean>

4.URL配置：

在controller和请求action上配置

@RequestMapping(value = "/anno")

5.请求方式配置：

@RequestMapping(value = "/register1.action", method = {RequestMethod.POST, RequestMethod.GET})

@RequestMapping(value = "/register", method = RequestMethod.POST)

若是不配置method，默认支持全部请求方式

6.请求参数接收：

1.变量直接接收：方法的变量名要和表单的name值保持一致，多用于get查询请求

 @RequestMapping(value = "/register1.action", method = {RequestMethod.POST, RequestMethod.GET})
    public String register1(Model model, String name, int age, boolean man) {

        model.addAttribute("message", "注册成功");
        return "success";
        // return "/WEB-INF/jsp/success.jsp";

    }

2.模型绑定接收：方法的变量名要和表单的name值保持一致，能够设置多个模型，多用于表单提交

 @RequestMapping(value = "/register", method = RequestMethod.POST)
    public String register(Model model, Student student) {
        System.out.println(student.getBirthday());
        model.addAttribute("message", "注册成功");
        model.addAttribute("student", student);

        return "success";
        // return "/WEB-INF/jsp/success.jsp";

    }

3.数组参数接收：批量删除时用于接收ids，批量添加

ids为checkbox的名称

   @RequestMapping(value = "/batchDelete.action")
    public String register(Model model, Integer[] ids) {
        for(int id :ids){
            System.out.println(id);
        }
        return "success";

    }

4.接收List<javaBean>集合

7.内部转发和重定向

内部转发，url不变：可使用model在多个action中传值，由于model是request域对象

 @RequestMapping(value = "/forward.action")
    public String forward(Model model) {
        return "forward:/anno/login.action";
    }

URL重定向，以url后缀的方式进行传值

    @RequestMapping(value = "/go.action")
    public String go(Model model) {
        return "redirect:/anno/login.action?id=3";
    }

8.action返回json和字符串

第一步：导入json包

jackson-annotations-2.6.0-xh.jar

jackson-core-2.6.0-xh.jar

jackson-databind-2.6.0-xh.jar

jackson-jr-all-2.4.3-xh.jar

第二步：在action请求方法上使用@ResponseBody注解表示该方法的返回值放在响应体（Response Body）返回给用户

第三步：在springmvc xml文件中配置json解析适配器

    <!-- 注册json解析适配器 -->
    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
        <property name="messageConverters">
            <list>
                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
            </list>
        </property>
    </bean>

第四步：开发action

返回json

@RequestMapping(value = "/getJson.action")
    @ResponseBody
    public  Student getJson() {
        Student student = new Student();
        student.setName("测试");
        student.setMan(true);
        student.setBirthday(new Date());
        student.setAge(14);
        student.setScore(12.254);
        return student;
    }

返回字符串

@RequestMapping(value = "/getString.action",method = RequestMethod.GET)
    @ResponseBody
    public String getString() {
        return "直接返回字符串";
    }

9.在action中获取当前请求的request

在controller中添加以下特性：能够放在baseController

@Autowired
protected HttpServletRequest request; //自动注入request

mybatis

1、入门开发步骤

1.导入相关jar包

mybatis3.4.2核心开发包

asm-5.1.jar
cglib-3.2.4.jar
commons-logging-1.1.3.jar
log4j-1.2.17.jar
mybatis-3.4.2.jar

mysql驱动包

mysql-connector-java-5.1.7-bin.jar

2.定义实体及实体映射文件

定义member实体

package com.eggtwo.entity;


import java.math.BigDecimal;
import java.util.Date;

public class Member {
    private int id;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    private String name;
    private int age;
    private Date birthday;
    private boolean man;
    private BigDecimal score;

    public BigDecimal getScore() {
        return score;
    }

    public void setScore(BigDecimal score) {
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public boolean isMan() {
        return man;
    }

    public void setMan(boolean man) {
        this.man = man;
    }
}

View Code

定义MemberMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--映射文件命名空间：要惟一-->
<mapper namespace="memberDao">
    <!--
    *******当实体属性和表字段名称一致的话resultMap标签能够省略********
    resultMap标签：映射实体和表关系
    id:映射关系id,要惟一
    type:实体全路径
    -->
    <resultMap id="memberMap" type="com.eggtwo.entity.Member">
        <!--id：映射主键属性
        result:映射非主键属性
        property:实体属性名称
        column:表字段名称
        -->
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="age" column="age"/>
        <result property="birthday" column="birthday"/>
        <result property="man" column="man"/>
        <result property="score" column="score"/>
    </resultMap>

    <insert id="add" parameterType="com.eggtwo.entity.Member" useGeneratedKeys="true" keyProperty="id">
      insert  into t_member(name,age,birthday,man,score)
       values(#{name},#{age},#{birthday},#{man},#{score})
    </insert>

    <update id="update" parameterType="com.eggtwo.entity.Member">
        update t_member set
        name = #{name},
        age = #{age},
        birthday = #{birthday},
        man = #{man},
        score = #{score}
        where id = #{id}
    </update>

    <delete id="delete" parameterType="int">
        delete from t_member where id = #{id}
    </delete>

    <!-- <select id="getById" parameterType="int" resultType="com.eggtwo.entity.Member">-->
    <!--resultType使用mybatis.xml中设置的别名，这样能够简化难度-->
    <select id="getById" parameterType="int" resultType="memberEntity">
        select id,name,age,birthday,man,score
        from  t_member
        where id=#{id}
    </select>
    <!--
    理论上resultType的值应该是:List<com.eggtwo.entity.Member>
    实际上只须要写List集合中的类型就能够
    -->
    <select id="getAll" resultType="com.eggtwo.entity.Member">
        select *
        from  t_member
    </select>
    <!--分页：多参数的写法-->
    <select id="getPageList" parameterType="map" resultType="com.eggtwo.entity.Member">
        select id,name,age,birthday,man,score
         from t_member limit #{start},#{size}
    </select>
</mapper>

View Code

3.定义mybatis.cfg.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 加载类路径下的属性文件 -->
    <!--加载数据库链接配置信息-->
    <properties resource="jdbc.properties"/>
    <!-- 设置类型别名 -->
    <typeAliases>
        <!--设置实体类Member的别名：memberEntity-->
        <typeAlias type="com.eggtwo.entity.Member" alias="memberEntity"/>
    </typeAliases>

    <!-- 设置一个默认的链接环境信息 -->
    <environments default="mysql_developer">


        <!-- 链接环境信息，取一个任意惟一的名字 -->
        <environment id="mysql_developer">
            <!-- mybatis使用jdbc事务管理方式 -->
            <transactionManager type="jdbc"/>
            <!-- mybatis使用链接池方式来获取链接 -->
            <dataSource type="pooled">
                <!--配置与数据库交互的4个必要属性 -->
                <!-- 直接配置方式，不推荐-->
                <!--<property name="driver" value="com.mysql.jdbc.Driver"/>-->
                <!-- <property name="url" value="jdbc:mysql://127.0.0.1:3306/test"/>-->
                <!--<property name="username" value="root"/>-->
                <!-- <property name="password" value="123456"/>-->


                <!--直接在jdbc.properties文件中配置链接-->
                <property name="driver" value="${mysql.driver}"/>
                <property name="url" value="${mysql.url}"/>
                <property name="username" value="${mysql.username}"/>
                <property name="password" value="${mysql.password}"/>

            </dataSource>
        </environment>

    </environments>

    <!-- 加载映射文件-->
    <mappers>
        <mapper resource="com/eggtwo/entity/MemberMapper.xml"/>
    </mappers>
</configuration>

View Code

mybatis.cfg.xml加载的jdbc.properties文件

mysql.driver=com.mysql.jdbc.Driver
mysql.url=jdbc:mysql://127.0.0.1:3306/test
mysql.username=root
mysql.password=123456

4.定义mybatis帮助类：MybatisUtil

package com.eggtwo.dao;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.Reader;
import java.sql.Connection;

public class MybatisUtil {

    private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<SqlSession>();
    private static SqlSessionFactory sqlSessionFactory;
    /**
     * 加载位于src/mybatis.xml配置文件
     */
    static{
        try {
            Reader reader = Resources.getResourceAsReader("mybatis.cfg.xml");
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    /**
     * 禁止外界经过new方法建立
     */
    private MybatisUtil(){}
    /**
     * 获取SqlSession
     */
    public static SqlSession getSqlSession(){
        //从当前线程中获取SqlSession对象
        SqlSession sqlSession = threadLocal.get();
        //若是SqlSession对象为空
        if(sqlSession == null){
            //在SqlSessionFactory非空的状况下，获取SqlSession对象
            sqlSession = sqlSessionFactory.openSession();
            //将SqlSession对象与当前线程绑定在一块儿
            threadLocal.set(sqlSession);
        }
        //返回SqlSession对象
        return sqlSession;
    }
    /**
     * 关闭SqlSession与当前线程分开
     */
    public static void closeSqlSession(){
        //从当前线程中获取SqlSession对象
        SqlSession sqlSession = threadLocal.get();
        //若是SqlSession对象非空
        if(sqlSession != null){
            //关闭SqlSession对象
            sqlSession.close();
            //分开当前线程与SqlSession对象的关系，目的是让GC尽早回收
            threadLocal.remove();
        }
    }






}

View Code

5.定义MemberDao测试mybatis增删查改

View Code

6.测试

 public static void main(String[] args) throws Exception {
        Connection conn = MybatisUtil.getSqlSession().getConnection();
        System.out.println(conn != null ? "链接成功" : "链接失败");
        MemberDao memberDao = new MemberDao();
        Member member = new Member();
        member.setId(2);
        member.setAge(14);
        member.setName("张三1");
        member.setBirthday(new Date());
        member.setMan(true);
        member.setScore(new BigDecimal(123.24));
        memberDao.add(member);
        //  memberDao.update(member);
        // memberDao.delete(3);
        Member member1 = memberDao.getById(2);
        System.out.println(member1.getName());
        List<Member> memberList = memberDao.getPageList(2,2);
        System.out.println("size:"+memberList.size());
        for (Member m : memberList){
            System.out.println(m.getId());
        }
    }

View Code

2、动态sql查询

MybatisUtil

java web开发入门

servlet

JSP

1.特色：

2.建立方式：

3.生命周期：

4.jsp语法

5.jsp内置对象

6.EL表达式

7.jsp标签

JavaBean

mysql

struts

1.开发步骤

2.执行流程

Hibernate

1.开发流程

2.映射详解

spring

1.spring简介

2.spring开发步骤

2.spring IOC容器的配置

3.spring和strut结合

4.代理模式

5.Spring 注解实现AOP编程

6.Spring XML实现AOP编程

7.Spring 切入点表达式

8.Spring 事务管理

SSH整合

1.引入jar包

2.配置xml

3.开发

spring mvc

spring mvc工做流程

XML实现spring mvc

注解实现spring mvc

mybatis

1、 入门开发步骤

2、 动态sql查询

1、入门开发步骤

2、动态sql查询