springMVC用法 以及一个简单的基于springMVC hibernate spring的配置

替代struts

1  web.xml中配置springmvc中央控制器

<?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" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>springmvc</display-name>

  <!-- SpringMVC中央控制器 -->
   <!--  Spring MVC 的Servlet,它将加载WEB-INF/mvc-servlet.xml 的
    配置文件,以启动Spring MVC模块-->
  <servlet>
      <servlet-name>mvc</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 代表在容器启动时就初始化,不写的时候代表在第一次请求的时候完成初始化,
        数字越小初始化越靠前-->
      <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
      <servlet-name>mvc</servlet-name>
    <!-- 在spring中要写/而不是/* -->
      <url-pattern>/</url-pattern>
  </servlet-mapping>

  <!-- Spring 容器启动监听器  -->
  <listener>
      <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  <!--spring服务层配置文件都放在以applicationContext开头的xml文件中,比如数据源 事务等-->
  <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:applicationContext*.xml</param-value>
  </context-param>

</web-app>

2

web.xml 中定义了一个名为 mvc 的 Spring MVC 模块,按照 Spring MVC 的契约,需要在
WEB-INF/mvc-servlet.xml 配置文件中定义 Spring MVC 模块的具体配置。mvc-servlet.xml
的配置内容如下所示:
在WEB-INF建立xxx-servlet.xml 其中xxx代表 web.xml中的<servlet-name>mvc</servlet-name>
名字一致,所以我们在这里建立mvc-servlet.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: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/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
<!-- 组件扫描 扫描springmvc的controller部分 -->
<!--对包中的所有类进行扫描,以完成Bean创建和自动依赖注入的功能-->
    <context:component-scan base-package="com.kaishengit.controller"/>
    <!-- 使用上面导入的schema/mvc  启用注解-->
    <mvc:annotation-driven/>

    <!-- 静态资源  **该目录及其子目录  <img  src="/static/image/kaola.jpg" width="300">-->
    <mvc:resources location="/static/" mapping="/static/**"/>

    <!-- 单纯的跳转,比如跳转到静态网页等 比如请求根的时候到index.jsp -->
    <mvc:view-controller path="/" view-name="index"/>

    <!-- 视图解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
        <!-- 让它支持jstl -->
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/views/"/>
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 文件上传解析器 -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 解析request的编码 ,Default is ISO-8859-1 -->
        <property name="defaultEncoding" value="UTF-8" />
        <!-- 设置最大允许的大小(字节)。-1表示没有限制(默认) 1024*1024*10=10MB -->
        <property name="maxUploadSize" value="1048576000" />
        <!--被允许的最大的内存的大小,Default is 10240 bytes -->
        <property name="maxInMemorySize" value="20480" />
        <!-- 一个类似懒加载的属性.可以定义该属性.让解析文件的时候再抛异常,然后Controller中定义异常处理的方法 -->
        <property name="resolveLazily" value="true" />
    </bean>

</beans>

3 写controller组件

import java.io.File;
import java.io.IOException;
import java.io.InputStream;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.commons.io.FileUtils;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import com.kaishengit.entity.User;
/*我们可以看出 HelloController 和一般的类并没有区别,
它没有实现任何特殊的接口,因而是一个地道的 POJO。让这个 POJO特殊就是 Spring MVC 的注解!*/
/*@Controller、@Service 以及 @Repository 和 @Component 注解的作用是等价的:
 * 将一个类成为 Spring 容器的 Bean。由于 Spring MVC 的 Controller 必须事先是一个 Bean,
 * 所以 @Controller 注解是不可缺少的。 */
@Controller
/* 类似与namespace */
@RequestMapping("/book")
public class HelloController {
/* 与struts不一样的是返回值可以有也可以没有void
    struts请求方式是加@action注解,springmvc是加@RequestMapping(value="/upload",method=RequestMethod.POST)
    当只写@RequestMapping(method=RequestMethod.POST)的时候默认请求/book(也就是namespace)路径
    代表请求的路径是/book/upload,以post的方法提交
        return "hello";跟前面配置的视图解析器拼凑成一个路径:就代表前往WEB-INF/views/hello.jsp页面
        return "book/hello"跟前面配置的视图解析器拼凑成一个路径:就代表前往WEB-INF/views/book/hello.jsp页面*/

---------------------------------------------------    

    // 两个相同的请求路径/book/add 但是请求方式不一样,这个get在这里代表我要去添加页
    @RequestMapping(value="/add",method=RequestMethod.GET)
    // 想使用的东西都可以从参数中传进来
    public ModelAndView add(HttpSession session,HttpServletRequest request,HttpServletResponse response) {
        // 页面传参方式1(使用的是request)    返回值是ModelAndView
        ModelAndView mav = new ModelAndView();
        mav.addObject("name", "Rose");
        // 去哪里
        mav.setViewName("book/add");
        // 放进session中
        session.setAttribute("name", "sessionName");
        // 放入application中,先用session获取application
        ServletContext application = session.getServletContext();
        application.setAttribute("name", "appName");

        System.out.println("add");
        return mav;
    }

    /* 两个相同的请求路径/book/add 但是请求方式不一样,这个get在这里代表我要去添加页
    @RequestMapping(value="/add",method=RequestMethod.GET)
    public String add(Model model) {
        //页面传参方式2(使用的是request),返回值是String
        model.addAttribute("name","jeck");

        return "/book/add";
    }*/

    // 接受表单的值只需要传入表单的name属性值,username要与表单中要传进来的name属性值一致
    @RequestMapping(value="/add",method=RequestMethod.POST)
    public String save(String username) {
        System.out.println(username);
        return "redirect:/book/add";
    }

    // 或者当表单非常多的时候,用对象的形式

    // 两个相同的请求路径/book/add 但是请求方式不一样,这个post在这里代表我要去提交表单
    @RequestMapping(value="/add",method=RequestMethod.POST)
    /* 表单形式不用变,不用写成name="user.username"仍然用原来的name="username"
        springmvc会自动尝试能不能加入到user对象中,不能加进去的仍然是原来的方式接受比如String email
        RedirectAttributes指操作成功后给一个提示,然后刷新后提示消失*/

    public String save(User user,String zip,RedirectAttributes redirectAttributes) {
        System.out.println("Hello,"+user.getUsername() + " : " + user.getPassword() + " : " + zip);

        redirectAttributes.addFlashAttribute("message", "保存成功");
        // 表示重定向到/book/add 重定向是get请求
        return "redirect:/book/add";
    }

--------------------------------------------------------------------    

    /* 比如ajax返回一个字符串,直接return "xxx"
        但是返回值是String的时候,springmvc会认为返回的是路径的名字--
        所以加@ResponseBody表示这是一个相应的内容*/
    @RequestMapping("/message")
    public @ResponseBody String showMessage() {
        return "I love you";
    }
    // 如果返回的是user(实体类),会自动转换成json 需要导入jackson-all-1.8.10.jar
    @RequestMapping(value="/user",method=RequestMethod.GET,produces={"application/json;charset=UTF-8"})
    // 也可以加在方法之上
    @ResponseBody
    public User showUser() {
        User user = new User();
        user.setUsername("张三丰");
        user.setPassword("123123");
        return user;
    }

-------------------------------------------------------    

    /* url传参 */
    @RequestMapping("/show/{id1}")
    /* 传三个参数,以逗号隔开在url中就是用逗号分隔,用斜杠隔开,在url中就是用斜杠分隔
    @RequestMapping("/show/{id1},{id2},{id3}") */
    /* 加正则表达式
    @RequestMapping("/show/{id1:\\d+},{id2:\\d+},{id3:\\d+}") */
    /* 接受url中传来的参数,但是我们不知道这个传来的参数是从url中获得的,还是从表单中获得的,
        所以加@PathVariable,代表是从url中获取 参数中的id分别对应上面传来的id,名字要一致*/
    public String show(@PathVariable int id1,@PathVariable int id2,@PathVariable int id3) {
        System.out.println("ID:" + id1);
        System.out.println("ID:" + id2);
        System.out.println("ID:" + id3);
        return "book/add";
    }
    /* 如果还想用原始的?xx=xx传参看下面,有的时候还真需要原始的?传参 */
----------------------------------------------------------------
    @RequestMapping("/page")
    public String page(int p) {
        System.out.println("pageNo:" + p);
        return "book/add";
    }

    @RequestMapping("/page")
    /* 如果参数可有可无@RequestParam,默认是1 */
    public String page(@RequestParam(value="p",required=false,defaultValue="1")int p) {
        System.out.println("pageNo:" + p);
        return "book/add";
    }

-------------------------------------------------------------
    /* 文件上传 commons-fileupload-1.2.2.jar commons-io-2.4.jar
        需要在xxx-servlet.xml配置文件上传解析器*/

<form action="/book/upload" method="post" enctype="multipart/form-data">
    <input type="file" name="pic">
    <input type="text" name="username">
    <button>保存</button>
</form>

    @RequestMapping(value="/upload",method=RequestMethod.POST)
    /* MultipartFile接受文件对象 */
    public String upload(String username,MultipartFile pic) {

        if(!pic.isEmpty()) {
            /*<!-- System.out.println("fileName:" + pic.getName());获取的是表单中name的属性pic -->*/
            System.out.println("fileName:" + pic.getOriginalFilename());
            System.out.println("fileSize:" + FileUtils.byteCountToDisplaySize(pic.getSize()));
            System.out.println("Content-type:" + pic.getContentType());
            System.out.println("username:" + username);
        /*     方法1: 获得输入流了,接下来你懂的
            InputStream inputStream = pic.getInputStream();
            */
            try {
            /* 方法2: */
                pic.transferTo(new File("C:/kaola.jpg"));
            } catch (Exception e) {
                e.printStackTrace();
            }

        } else {
            System.out.println("file is empty");
        }

        return "redirect:/book/add";
    }

}

好了,下面介绍一个spring  springMVC hibernate的 框架搭建

--------------------------------------------------------------------
--------------------------------------------------------------------
--------------------------基于springMVC,hibernate,spring------------
--------------------------------------------------------------------
--------------------------------------------------------------------

首先是web.xml

<!-- 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" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>springmvc</display-name>

  <!-- 字符集过滤器 -->
  <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>

  <!-- OpenSessionInView -->
  <filter>
      <filter-name>openSessionInView</filter-name>
      <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
  </filter>
  <filter-mapping>
      <filter-name>openSessionInView</filter-name>
      <url-pattern>/*</url-pattern>
  </filter-mapping>

  <!-- SpringMVC中央控制器 -->
  <!--  Spring MVC 的Servlet,它将加载WEB-INF/mvc-servlet.xml 的
    配置文件,以启动Spring MVC模块-->
  <servlet>
      <servlet-name>mvc</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
      <servlet-name>mvc</servlet-name>
      <url-pattern>/</url-pattern>
  </servlet-mapping>

  <!--spring服务层配置文件都放在以applicationContext开头的xml文件中,比如数据源 事务等-->
  <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:applicationContext*.xml</param-value>
  </context-param>

   <!--  Spring 容器启动监听器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

</web-app>

web.xml 中定义了一个名为 annomvc 的 Spring MVC 模块,按照 Spring MVC 的契约,需要在
WEB-INF/annomvc-servlet.xml 配置文件中定义 Spring MVC 模块的具体配置。mvc-servlet.xml
的配置内容如下所示:
在WEB-INF建立xxx-servlet.xml 其中xxx代表 web.xml中的<servlet-name>mvc</servlet-name>
名字一致,所以我们在这里建立mvc-servlet.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: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/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
<!-- 组件扫描 扫描springmvc的controller部分 -->
<!--对包中的所有类进行扫描,以完成Bean创建和自动依赖注入的功能-->
    <context:component-scan base-package="com.kaishengit.controller"/>
    <!-- 使用上面导入的schema/mvc  启用注解-->
    <mvc:annotation-driven/>

    <!-- 静态资源  **该目录及其子目录-->
    <mvc:resources location="/static/" mapping="/static/**"/>

    <!-- 单纯的跳转,比如跳转到静态网页等 比如请求根的时候到index.jsp -->
    <mvc:view-controller path="/" view-name="index"/>

    <!-- 视图解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
        <!-- 让它支持jstl -->
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <!-- 前缀 -->
        <property name="prefix" value="/WEB-INF/views/"/>
        <!-- 后缀 -->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 文件上传解析器 -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!-- 解析request的编码 ,Default is ISO-8859-1 -->
        <property name="defaultEncoding" value="UTF-8" />
        <!-- 设置最大允许的大小(字节)。-1表示没有限制(默认) 1024*1024*10=10MB -->
        <property name="maxUploadSize" value="1048576000" />
        <!--被允许的最大的内存的大小,Default is 10240 bytes -->
        <property name="maxInMemorySize" value="20480" />
        <!-- 一个类似懒加载的属性.可以定义该属性.让解析文件的时候再抛异常,然后Controller中定义异常处理的方法 -->
        <property name="resolveLazily" value="true" />
    </bean>

</beans>

spring
 根目录配置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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"
>

<!-- Controller在之前的配置springmvc的时候已经扫描过了.扫描的时候记得把去除掉 -->
    <context:component-scan base-package="com.kaishengit">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

    <!-- 配置数据源 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="username" value="${jdbc.name}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="minIdle" value="5"/>
        <property name="maxActive" value="10"/>
        <property name="maxWait" value="5000"/>
    </bean>

    <!-- Hibernate SessionFactory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="packagesToScan" value="com.kaishengit.pojo"/>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.cache.use_query_cache">true</prop>
                <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
            </props>
        </property>
    </bean>

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

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

</beans>

ehcache.xml

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

    <diskStore path="java.io.tmpdir"/>

    <defaultCache
        maxElementsInMemory="1000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
    />

    <!--
    <cache name="com.kaishengit.pojo.User"
        maxElementsInMemory="100"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
    />
     -->
  </ehcache>

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///book?useUnicode=yes&characterEncoding=UTF-8
jdbc.name=root
jdbc.password=root
时间: 2024-11-02 23:21:12

springMVC用法 以及一个简单的基于springMVC hibernate spring的配置的相关文章

一个简单的基于HTTP协议的屏幕共享应用

HTTP协议可以能是应用层协议里使用最广泛并且用途最多样的一个了.我们一般使用HTTP协议来浏览网页,但是HTTP协议还用来做很多其它用途.对开发人员来讲很常见的一种就是用HTTP协议作为各种版本控制系统和发布系统的一种底层协议,比如SVN/GIT/WebDav等等都有HTTP的支持.甚至一些数据库用HTTP作为链接的底层协议.HTTP的特点是简单,基于文本(可读),容易扩展(各种头部随便加),支持代理(让很多没有外网连接的主机可以通过HTTP代理访问外部主机,实际上HTTP Proxy Tun

一个简单的基于内容的推荐算法

最近闲下来又开始继续折腾推荐系统了,声明一下,本文只是介绍一下最基础的基于内容的推荐系统(Content-based recommender system)的工作原理,其实基于内容的推荐系统也分三六九等Orz,这里只是简单的较少一下最原始的.最基本的工作流程. 基于内容的推荐算法思路很简单,它的原理大概分为3步: 1.为每个物品(Item)构建一个物品的属性资料(Item Profile) 2.为每个用户(User)构建一个用户的喜好资料(User Profile) 3.计算用户喜好资料与物品属

关于ExpandableListView用法的一个简单小例子

喜欢显示好友QQ那样的列表,可以展开,可以收起,在android中,以往用的比较多的是listview,虽然可以实现列表的展示,但在某些情况下,我们还是希望用到可以分组并实现收缩的列表,那就要用到android的ExpandableListView,今天研究了一下这个的用法,也参考了很多资料动手写了一个小demo,实现了基本的功能,但界面优化方面做得还不够好,有待改进,素材采用了Q版三国杀武将的图片,很有爱哈哈,下面直接上效果图以及源代码~!                     main.x

一个简单的基于Tornado二手房信息统计项目的开发实现

Purpose 最近因为要买房子,扫过了各种信息,貌似lianjia上的数据还是靠点谱的(最起码房源图片没有太大的出入),心血来潮想着做几个图表来显示下房屋的数据信息,顺便练练手. 需求分析 1从lianjia的网站上获取关键的房屋信息数据,然后按照自己的需求通过图表显示出来. 2每天从lianjia的网站上获取一次数据 3以上海地区为主(本人在上海) 4最终生成图表有:房屋交易总量,二手房均价,在售房源,近90天成交量,昨日带看次数 分析获取网站数据 1 数据源 数据的获取主要是从两个地方:

一个简单的基于用户的推荐系统

DataModel model=new FileDataModel(new File("intro.csv")); //.csv是逗号文件 UserSimilarity similarity=new PearsonCorrelationSimilarity(model); UserNeighborhood neighborhood=new nearestNUserNeighborhood(2,similarity,model); Recommender recommender=new

一个简单的基于数据库实现的多机任务抢占调度

一般的协调工作,让zookeeper来做那是最好的,问题是你得部署zookeeper.如果没有能否模拟一个协调者呢?这是本篇文章需要介绍的内容. 背景 有合同约定,如果总消费额达到一定的额度,需要启动折扣,达到另一个更高的额度后,会启动另一个折扣.用户的消费记录都是小额的,如1毛一笔,折扣需要详细到每一笔交易.现在已经有了很大批量的这种数据,需要计算总价.应用部署了3台机器,如何让3台机器都可以参与处理,并且一个合同的消费数据只能由一台机器处理,并且,如果这台机器处理了合同的部分数据死掉后,需要

一个简单的基于jQuery的焦点图(幻灯片)代码

本代码实现的是横向循环滚动, <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <title>jQuery的焦点图(幻灯片)</title> <sc

一个简单的基于多进程实现并发的Socket程序

在单进程的socket的程序的基础上,实现多进程并发效果的思路具体是:在server端开启"链接循环",每建立一次链接就生成一个Process对象进行server-client的互动,而client端不用做任何变化,因为对于client来说每运行一次程序就相当于与server端建立了一个链接. 具体代码如下: # -*- coding: utf-8 -*- # -*- Author: WangHW -*- import socket import os from multiproces

一个简单的基于MINI2440开发板的启动代码

1. S3C2440大概的启动流程(NAND启动): ①设置CPU为SVC模式 ②关闭看门狗 ③屏蔽中断 ④关闭MMU ⑤初始化时钟 ⑥初始化内存(SDRAM) ⑦初始化栈指针(SP, R13) ⑧初始化NAND Flash ⑨拷贝代码从NAND到内存 ⑩清除BSS段 最后,跳转至C语言的Main函数执行 2. 汇编语言源代码 .text .global _start _start: b reset ldr pc, _undifined_instruction ldr pc, _software