SpringMVC4+Hibernate4学习笔记

（一）配置详解

(注:本文是以前几篇博客的简单合并，未做更新)

鉴于目前资料大多数都是基于spring3的配置，本人在最初搭建的时候遇到很多问题，由此记录下来仅供参考

使用的jar文件

springframework4.0.6(为了方便整个先导入)
hibernate4.3.6 /required/*下所有jar 以及 /optional下的c3p0(为了使用c3p0作为dataSource，使用其连接池)
jstl.jar standard.jar ——为了使用jstl标签库
apoalliance.jar ——在AOP一些地方依赖这个库
commons-logging.jar

配置详细步骤

  • 第一步，配置web.xml
     <?xml version="1.0" encoding="UTF-8"?>
 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee"
     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                         http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
     id="WebApp_ID" version="3.0">

     <display-name>app</display-name>

     <!-- context启动时加载hibennate的配置文件 -->
     <context-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>/WEB-INF/spring-*.xml</param-value>
     </context-param>

     <listener>
         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
     </listener>

     <!-- 设置spring的前端分发器，接受请求 -->
     <servlet>
         <servlet-name>myservlet</servlet-name>
         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
         <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>myservlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <!-- 默认错误页面的设置 -->
    <error-page>
        <error-code>404</error-code>
        <location>/WEB-INF/jsp/404.jsp</location>
    </error-page>

    <!-- <error-page>
    <exception-type>java.lang.Exception</exception-type>
        <location>/WEB-INF/jsp/exception.jsp</location>
    </error-page> -->

 </web-app>
  • 第二步，myservlet-servlet.xml（DispatcherServlet）的配置文件相关部分，注意，如果在配置中用到了aop，tx，mvc等标签，须在xmlns中导入。
      <?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:mvc="http://www.springframework.org/schema/mvc" xmlns:tx="http://www.springframework.org/schema/tx"
         xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
         xmlns:util="http://www.springframework.org/schema/util"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
                            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
                            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
                            http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

      <!-- 扫描注解配置的包 -->
      <context:component-scan base-package="com.tan.*" />

      <!-- 基于注释的事务，当注释中发现@Transactional时，使用id为“transactionManager”的事务管理器 -->
      <!-- 如果没有设置transaction-manager的值，则spring以缺省默认的事务管理器来处理事务，默认事务管理器为第一个加载的事务管理器 -->
      <tx:annotation-driven transaction-manager="transactionManager" />

      <!-- 设置spring的mvc用注解 -->
      <mvc:annotation-driven />

      <!-- 设置handler的映射方式，前面注解是其中一种 -->
      <!-- HandlerMapping <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
      <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/> -->

      <!-- 设置试图的解析ViewResolver -->
      <bean
          class="org.springframework.web.servlet.view.InternalResourceViewResolver">
      <!-- <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/> 此处不加这行似乎也能在jsp中用jstl，只要正确引入了tag-->
          <property name="prefix" value="/WEB-INF/jsp/" />
          <property name="suffix" value=".jsp" />
      </bean>
      <!-- 可以使用基于url的handlermapping <bean name="/hello" class="com.tan.controller.MyController"/> -->
  </beans>
  • 第三步，hibenate相关的配置，spring-hibernate.xml。配置数据源->交给sessionFactory->交给spring事物管理transactionManager->spring接手
      <?xml version="1.0" encoding="UTF-8"?>
  <beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:context="http://www.springframework.org/schema/context"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
         xmlns:aop="http://www.springframework.org/schema/aop"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
                             http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                             http://www.springframework.org/schema/context
                             http://www.springframework.org/schema/context/spring-context-4.0.xsd
                             http://www.springframework.org/schema/aop
                             http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
                             http://www.springframework.org/schema/tx
                             http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">

  <!-- Hibernate4 -->
  <!-- shiyongproperties文件保存jdbs以及hibernate的相关变量，在具体配置处使用属性zhi值，必须在Spring配置文件的最前面加载，放在src目录 -->
  <context:property-placeholder location="classpath:persistence-mysql.properties" />

  <!-- 获取数据源的几种方式DriverManagerDataSource、dbcp、c3p0，后两种支持连接池 -->
  <!-- class="org.apache.tomcat.dbcp.dbcp.BasicDataSource" 有连接池作用 -->
  <!-- class="org.springframework.jdbc.datasource.DriverManagerDataSource"无连接池作用 -->
  <!-- <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
           <property name="driverClassName" value="${jdbc.driverClassName}" />
           <property name="url" value="${jdbc.url}" />
           <property name="username" value="${jdbc.user}" />
           <property name="password" value="${jdbc.pass}" />
       </bean> -->

  <!-- c3p0 有连接池作用，使用properties文件下的属性值，也可以直接填-->
  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
      <property name="driverClass" value="${jdbc.driverClassName}" />
      <property name="jdbcUrl" value="${jdbc.url}" />
      <property name="user" value="${jdbc.user}" />
      <property name="password" value="${jdbc.pass}" />
      <property name="minPoolSize" value="2" />
      <property name="maxPoolSize" value="50" />
      <property name="initialPoolSize" value="10" />
      <property name="maxIdleTime" value="60" />
      <property name="acquireIncrement" value="2" />
  </bean>

  <!-- 配置sessionFactory，统一管理一个数据库的连接 -->
  <bean id="sessionFactory"
      class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
      <property name="dataSource" ref="dataSource" />
      <property name="packagesToScan">
          <list>
              <!-- 可以加多个包，需要hibenate映射的类的包 -->
              <value>com.tan.model</value>
          </list>
      </property>
      <property name="hibernateProperties">
          <props>
              <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
              <prop key="hibernate.dialect">${hibernate.dialect}</prop>
              <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
              <!-- <prop key="hibernate.current_session_context_class">thread</prop> -->
          </props>
      </property>
  </bean>

  <!-- 配置Hibernate事务管理器 -->
  <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
      <property name="sessionFactory" ref="sessionFactory" />
  </bean>

  <!-- 配置事务异常封装 -->
  <bean id="persistenceExceptionTranslationPostProcessor" class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />
  </beans>
  • 第四步，添加persistence-mysql.properties文件，如果在spring-hibenate.xml直接配置数据源的值，就不需要
      # jdbc.X
  jdbc.driverClassName=com.mysql.jdbc.Driver
  jdbc.url=jdbc:mysql://localhost:3306/springmvc（你的数据库名）?createDatabaseIfNotExist=true&amp;useUnicode=true&amp;characterEncoding=utf8
  jdbc.user=root
  jdbc.pass=
  # hibernate.X
  hibernate.connection.driverClass=com.mysql.jdbc.Driver
  hibernate.connection.url=jdbc:mysql://localhost:3306/springmvc（你的数据库名）
  hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
  hibernate.connection.username=root
  hibernate.connection.password=
  hibernate.show_sql=true
  hibernate.hbm2ddl.auto=update #如果没有表则创建，如果表结构更改则自动更新

（二）一些名词

  • MVC模型-视图-控制器

    Spring MVC中的mvc和通常的web框架如，django、ROR、thinkphp、lavarel等都是很类似的，个人感觉区别在于Spring MVC中的model层功能更多的是有DAO+Service两层来完成，像front dispatcher、controller、viewresolver和其他框架都是很类似的

  • DAO数据访问层

    DAO封装了对数据库的操作，可能是原子级的操作由Service组装，也可能是稍复杂的操作。供Service业务层调用

  • Service业务逻辑层

    封装了业务逻辑的相关操作，由控制器层调用，这一层不是必须的，也可经控制器直接调用DAO中的方法

  • AOP面向切面编程

    面向切面编程简单地理解就是把多个业务逻辑的共同功能模块提取出来，如回话管理、权限认证等。在django的auth模块，以及thinkphp的Behavior行为驱动层都是AOP的使用例子

  • DI依赖注入

    依赖注入的一个简单例子就是Service层中注入需要用到的一个或多个DAO，在Controller中注入Service，使用annotation注入极大简化了代码的编写

  • ORM对象关系映射

    这个与大多数orm框架的理念都是类似的，在hibernate中使用对象映射表，对象的实例映射表中一条记录

  • sessionFactory生成session的工厂

    负责创建session，session是hibernate暴露给开发者的操作数据库的接口，在DAO中使用session通过save/update/saveorupdate/delete等方法或者hsql、原生sql访问数据库

  • Tansaction事务

    这个与通常的数据库的事务的概念差不多，在springmvc与hibenate集成中，hibernate将transacition交给HibernateTransactionManager管理

  • Datasource

    数据源就是hibernate的连接数据库的方式。通常有springmvc自带的DriverManagerDataSource、c3p0、dbcp，后两种支持连接池

（三）完整实例

  • POJO类，负责和数据库映射

      package com.tan.model;
  import javax.persistence.*;
  @Entity(name = "users") //映射到users表
  public class Users {

      public Users() {
          super();
      }
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  @Column(name = "id")
  private Integer id;
  @Column(name = "first_name", length = 32)
  private String first_name;
  @Column(name = "age")
  private Integer age;
  @Column(name = "last_name", length = 32)
  private String last_name;
  public Integer getId() {
      return id;
  }
  public void setId(Integer id) {
      this.id = id;
  }
  public String getFirst_name() {
      return first_name;
  }
  public void setFirst_name(String first_name) {
      this.first_name = first_name;
  }
  public Integer getAge() {
      return age;
  }
  public void setAge(Integer age) {
      this.age = age;
  }
  public String getLast_name() {
      return last_name;
  }
  public void setLast_name(String last_name) {
      this.last_name = last_name;
  }
  }

  • DAO层

      package com.tan.model;

  import java.util.List;
  import javax.annotation.Resource;
  import org.hibernate.Query;
  import org.hibernate.Session;
  import org.hibernate.SessionFactory;
  import org.springframework.stereotype.Repository;
  @Repository
  public class UsersDAO {
  @Resource(name = "sessionFactory")  //使用annotation注入sessionFactory
      private SessionFactory sessionFactory;
      public void setSessionFactory(SessionFactory sessionFactory) {
      this.sessionFactory = sessionFactory;
  }
  public SessionFactory getSessionFactory() {
      return sessionFactory;
  }
  public List<Users> getAllUser() {
      String hsql = "from users";
      Session session = sessionFactory.getCurrentSession();
      Query query = session.createQuery(hsql);
      return query.list();
  }
  public void insert(Users u) {
      Session session = sessionFactory.getCurrentSession();
      session.save(u);
  }
  }

  • Service层

      package com.tan.service;
  import java.util.List;
  import javax.annotation.Resource;
  import org.springframework.stereotype.Service;
  import org.springframework.transaction.annotation.Transactional;
  import com.tan.model.Users;
  import com.tan.model.UsersDAO;
  @Service("userService")
  @Transactional   //开启事务
  public class UserService {
      @Resource
      private UsersDAO userDao;
      public int userCount() {
          return userDao.getAllUser().size();
  }
  @Transactional(readOnly = true)
  public List<Users> getAllUsers() {
      return userDao.getAllUser();
  }
  public void insert(Integer age, String first_name, String last_name) {
      Users u = new Users();
      u.setAge(age);
      u.setFirst_name(first_name);
      u.setLast_name(last_name);
      userDao.insert(u);
  }
  public void insert1(Users u) {
      userDao.insert(u);
  }
  public UsersDAO getUserDao() {
      return userDao;
  }
  public void setUserDao(UsersDAO userDao) {
      this.userDao = userDao;
  }
  }

  • controller层

      package com.tan.controller;
  import java.util.List;
  import org.springframework.stereotype.Controller;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RequestMethod;
  import org.springframework.web.bind.annotation.ResponseBody;
  import org.springframework.web.bind.annotation.RequestParam;
  import org.springframework.web.bind.annotation.PathVariable;
  import org.springframework.web.servlet.ModelAndView;//不要引入错误的modelandview
  import com.tan.model.Users;
  import com.tan.service.UserService;
  import javax.annotation.Resource;
  @Controller
  @RequestMapping("/user")  //映射url
  public class UserController {
  @Resource(name = "userService") //注入service层
  private UserService service;
      @RequestMapping(value = "/man", method = RequestMethod.GET)
  public ModelAndView hello2() {
  ModelAndView mv = new ModelAndView();
  mv.addObject("message", "HelloMVC");
  // mv.setViewName("users");
  return mv;
  }
  @RequestMapping(value = "/count", method = RequestMethod.GET)
  public ModelAndView count() {
      int c = service.userCount();
      ModelAndView mv = new ModelAndView();
      mv.addObject("message", c);
      mv.setViewName("user/count");
      return mv;
  }
  @RequestMapping(value = "/list", method = RequestMethod.GET)
  @ResponseBody    //返回json
  public ModelAndView list() {
      List<Users> u = service.getAllUsers();
      ModelAndView mv = new ModelAndView();
      mv.addObject("u", u);
      // mv.setViewName("users");
      return mv;
  }
  @RequestMapping(value = "/add", method = RequestMethod.GET)
  public String insert() {
      return "user/add";
  }
  /*
   * @RequestMapping(value="/insert",method=RequestMethod.POST)
   *
   * @ResponseBody public ModelAndView insert(
   *
   * @RequestParam("age") Integer age,
   *
   * @RequestParam("first_name") String first_name,
   *
   * @RequestParam("last_name") String last_name ){
   *
   * service.insert(age,first_name,last_name); ModelAndView mv = new
   * ModelAndView(); return mv;
   *
   * }
   */
  @RequestMapping(value = "/insert", method = RequestMethod.POST)
  public String insert(Users u) {
      service.insert1(u);
      return "redirect:/user/list";
  }
  @RequestMapping("/path/{id}")   //pathinfo模式
  @ResponseBody
  public Integer path(@PathVariable("id") Integer id) {
  return id;
  }
  }

（四）注解式事务

  • 配置和使用

    • 在myservlet-servlet.xml里面添加

        <tx:annotation-driven transaction-manager="transactionManager" />

      不要加到spring-hibernate配置文件中，会产生session null错误

    • 确保数据库本身是支持事务的引擎
    • 在Service层使用事务，在整个类中用@Transactional声明会作用于所有public方法，在function里的@Transactional会覆盖class的. insert方法上没使用@Transactional，如果此时class上也没使用，则会报错，而insert1不会. 
        package com.tan.service;
  import java.util.List;
  import javax.annotation.Resource;
  import org.springframework.stereotype.Service;
  import org.springframework.transaction.annotation.Transactional;
  import com.tan.model.Users;
  import com.tan.model.UsersDAO;
  @Service("userService")
  @Transactional(readOnly = true)   //开启事务
  public class UserService {
      @Resource
      private UsersDAO userDao;
      public int userCount() {
          return userDao.getAllUser().size();
  }
  @Transactional(readOnly = true)
  public List<Users> getAllUsers() {
      return userDao.getAllUser();
  }

  public void insert(Integer age, String first_name, String last_name) {
      Users u = new Users();
      u.setAge(age);
      u.setFirst_name(first_name);
      u.setLast_name(last_name);
      userDao.insert(u);
  }

  @Transactional(propagation = Propagation.REQUIRED, readOnly = false)
  public void insert1(Users u) {
      userDao.insert(u);
  }
  public UsersDAO getUserDao() {
      return userDao;
  }
  public void setUserDao(UsersDAO userDao) {
      this.userDao = userDao;
  }
  }
    • 事务属性
      • 传播行为（propagation=..）

        常用的几个

        • PROPAGATION_REQUIRED—-必须运行在事务中
        • PROPAGATION_SUPPORTS—-事务不必须，但如果有事务则运行在事务中
        • PROPAGATION_NEVER——-不能运行在事务中，如果有则抛出异常
        • ….
      • 隔离级别(isolation = ) 默认完全隔离，可以适当放松隔离优化性能
      • 只读(readOnly = true)
      • 超时(timeout = )
      • 回滚规则(rollback-for = )

（五）简单Session登录管理

  • session登录实例，实现了四个方法login/logout/doLogin/testLogin,加入前面UserController中

      @RequestMapping(value = "/doLogin", method = RequestMethod.POST)
  public String doLogin(HttpServletRequest req,@RequestParam("user") String username, @RequestParam("pass") String password) {

  //System.out.println(username+"_"+password);
      if (username.equals( "user") && password.equals( "pass")) {
          HttpSession s = req.getSession();
          s.setAttribute("isLogin", "y");
          return "redirect:/user/testLogin";
      } else {
          return "redirect:/user/login";
      }
  }

  @RequestMapping("/login")
  public String login() {
      return "user/login";
  }

  @RequestMapping("/testLogin")
  public String testLogin(HttpServletRequest req) {
      if (req.getSession().getAttribute("isLogin") == "y") {
          return "user/home";
      } else {
          return "user/login";
      }
  }

  @RequestMapping("/logout")
  public String logout(HttpServletRequest req) {
      req.getSession().setAttribute("isLogin", null);
      return "user/login";
  }

  • 相应视图

      //login.jsp//
  <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  <html>
      <head>
          <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
          <title>Insert title here</title>
      </head>
  <body>
      <form action="/app/user/doLogin" method="post">
          user：<input type="text" name="user"><br />
          pass：<input type="text" name="pass"><br /> <input type="submit" value="login">
      </form>
  </body>
  </html>

  //home.jsp//
  <%@ page language="java" contentType="text/html; charset=UTF-8"
  pageEncoding="UTF-8"%>
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  <html>
      <head>
          <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
          <title>Insert title here</title>
      </head>
  <body>
      yes,login
      <br />
      <a href="/app/user/logout">logout</a>
  </body>
  </html>
时间： 2024-10-18 18:09:29

SpringMVC4+Hibernate4学习笔记的相关文章

spring学习笔记(21)编程式事务配置，service层概念引入

访问数据库事务导入 在我之前的文章<spring学习笔记(19)mysql读写分离后端AOP控制实例>中模拟数据库读写分离的例子,在访问数据库时使用的方法是: public <E> E add(Object object) { return (E) getSessionFactory().openSession().save(object); } 通过直接开启session而后保存对象.查询数据等操作,是没有事务的.而如果我们的项目规模变大,业务逻辑日益复杂,我们在一个方法中进行大

JetSpeed学习笔记(一)

笔记 JetSpeed学习笔记(一) fuweilin 2005-4-7 前言 参加了公司的portal的兴趣小组,今天对portal进行学习.首先上网看了看一些portal的资料,对portal.portlet.portlet container以及JSR168等概念有个基本的了解.决定进一步实战的方式感受portal,于是学习JetSpeed.     1.  JetSpeed介绍JetSpeed是Apache组织开发的一个采用Java和XML的开放源代码的企业信息门户的实现.门户可以让终端

PHP输入输出流学习笔记

  这篇文章主要介绍了PHP输入输出流学习笔记,PHP输入和输出流是通过php://来访问的,它允许访问 PHP 的输入输出流.标准输入输出和错误描述符,内存中.磁盘备份的临时文件流以及可以操作其他读取写入文件资源的过滤器,需要的朋友可以参考下 PHP输入和输出流是通过php://来访问的,它允许访问 PHP 的输入输出流.标准输入输出和错误描述符, 内存中.磁盘备份的临时文件流以及可以操作其他读取写入文件资源的过滤器. php://stdin, php://stdout 和 php://std

PHP学习笔记 （1） 环境配置与代码调试

一配置PHP环境 1.了解什么是PHP PHP("PHP: Hypertext Preprocessor",超文本预处理器的字母缩写) PHP,是英文超级文本预处理语言Hypertext Preprocessor的缩写.PHP 是一种 HTML 内嵌式的语言,是一种在服务器端执行的嵌入HTML文档的脚本语言,语言的风格有类似于C语言,被广泛的运用 2.PHP的背景和优势 PHP的发展背景 1).1994年由Rasmus Lerdorf创建,开始是一个简单的Perl语言编写的程序,用统计

Node.js 学习笔记之简介、安装及配置

 本文是Node.js学习笔记系列文章的第一篇,主要给大家讲解的是在Windows和Linux上安装Node.js的方法.软件安装版本以0.12.0为例.希望大家能够喜欢.     简单的说 Node.js 就是运行在服务端的 JavaScript. Node.js 是一个基于Chrome JavaScript 运行时建立的一个平台. Node.js是一个事件驱动I/O服务端JavaScript环境,基于Google的V8引擎,V8引擎执行Javascript的速度非常快,性能非常好. 谁适合阅

node.js学习笔记（9） 和谐模式

众所周知,ECMAScript 是一种开放的.国际上广为接受的脚本语言规范. 它本身并不是一种脚本语言.正如在 Web 应用程序中执行有用操作的 bean 集合(例如,Netscape 的 AWT)是 Sun 的 JavaBean 规范的一种实现一样,JavaScript 是 ECMAScript 规范的一种实现. 2015年6月17日,ECMA国际发布了EcmaScript2015,即EcmaScript6(以下简称ES6)草案的正式版.ES6是继ES5之后的一次主要改进,语言规范由ES5.1

php5学习笔记(转)

php5|笔记 作者: whhwq在phpv.net看到的感觉不错/*+-------------------------------------------------------------------------------+| = 本文为Haohappy读<<Core PHP Programming>> | = 中Classes and Objects一章的笔记 | = 翻译为主+个人心得 | = 为避免可能发生的不必要的麻烦请勿转载,谢谢 | = 欢迎批评指正,希望和所有

动态网页学习：JSP学习笔记全记录

js|笔记|动态|网页 JSP学习笔记(一)-----概述 JSP学习笔记(二)-----使用Tomcat运行JSP文件 JSP学习笔记(三)-----使用JSP处理用户注册和登陆 JSP学习笔记(四)-----JSP动作的使用 JSP学习笔记(五)-----JSP中使用JavaBean JSP学习笔记(六)-----在多个JSP页面之间传递参数 JSP学习笔记(七)-----猜数字游戏 JSP学习笔记(八)-----include的运用 JSP学习笔记(九)-----JSP标签库

java对象序列化学习笔记

java对象|笔记 目前网络上关于对象序列化的文章不少,但是我发现详细叙述用法和原理的文章太少.本人把自己经过经验总结和实际运用中的体会写成的学习笔记贡献给大家.希望能为整个java社区的繁荣做一点事情.    序列化的过程就是对象写入字节流和从字节流中读取对象.将对象状态转换成字节流之后,可以用java.io包中的各种字节流类将其保存到文件中,管道到另一线程中或通过网络连接将对象数据发送到另一主机.对象序列化功能非常简单.强大,在RMI.Socket.JMS.EJB都有应用.对象序列化问题在网