首页 > > 程序设计 > Java技术 >

Spring MVC深入学习

2019-02-20 00:47:02来源：博客园 阅读 ()

新老客户大回馈,云服务器低至5折

一、MVC思想

  • MVC思想简介：
      　MVC并不是java所特有的设计思想，也不是Web应用所特有的思想，它是所有面向对象程序设计语言都应该遵守的规范；MVC思想将一个应用部分分成三个基本部分：Model（模型）、View（视图）和Controller（控制器),这三个部分以最少的耦合协同工作，从而提高应用的可扩展性和可维护性；
  • MVC特点：
    • 多视图对应一个模型。按MVC模式，一个模型对应多个视图，可以减少代码的复制和维护量，这样一旦模式改变，易于维护；
    • 模型返回的数据和显示的逻辑分离。模型数据可以使用任何的显示技术，例如jsp、velocity模板或直接产生excel文档等；
    • 应用被分割为三层，降低了各层之间的耦合，提高了应用的可扩展性；
    • 控制层的概念很有效，他把不同的模型和不同的视图组合在一起，完成不同的请求。因此，控制层可以说包含了用户请求权限的概念；
    • MVC更符合软件工程化管理的精神，每一层的组件具有相似的特点，有利于通过工程化和工具化的方法产生管理程序代码；

二、SpringMvc的前端控制器DispatcherServlet

在许多的MVC框架中，都包含一个用于调度控制的Servlet。Spring MVC也提供了一个名为org.springframework.web.servlet.DispatcherServlet的Servlet充当前端控制器，所有的请求驱动都围绕这个DispatcherServlet来分派请求。

DispatcherServlet是一个Servlet（继承自httpServlet基类），在使用时需要把他配置到web.xml文件中，配置信息如下：

<servlet>
    <!-- servlet的名称 -->
    <servlet-name>springmvc</servlet-name>
    <!-- servlet对应的java类 -->
    <servlet-class>
        org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    
    <!-- 当前Servlet的参数信息 -->
    <init-param>
        <!-- contextConfigLocation是参数名称，该参数的值包含SpringMVC的核心配置文件路径-->
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/springmvc-config.xml</param-value>
    </init-param>

    <!-- 在tomcat启动时立即加载servlet -->
    <load-on-startup>1</load-on-startup>
</servlet>
<!-- servlet映射声明 -->
<servlet-mapping>
    <!-- 请求对用的servlet名称 -->
    <servlet-name>springmvc</servlet-name>
    <!-- 监听当前所有请求 -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

三、SpringMvc的后端控制器Handle（两种配置方式）

  • 实现Controller接口
  • 注解（重点）

　　　DispatcherServlet在Spring当中充当前端控制器的角色，他的核心功能是分发请求，请求会被分发给对应处理的java类，Spring MVC 中称为Handle；Controller接口的实现类只能处理一个单一请求动作，而Spring2.5之后新增的基于注解的控制器可以支持同时处理多个请求动作，并且无需实现任何接口，更加灵活

四、Spring MVC注解

  • @Controller注解

        org.springframework.stereotype.Controller注解类型用于指示Spring类的实例是一个控制器，@Controller用于标记一个类，使用它标记的类就是一个SpringMVC Controller对象，即一个控制器类Spring使用扫描机制查找应用程序中所有基于注解的控制器类。分发处理器会扫描使用了该注解的类的方法，并检测该方法是否使用了@RequestMapping注解，使用了的方法才是真正处理请求的处理器。
 
        保证spring能找到控制器，需完成两件事：
    • 在SpringMVC核心配置文件头文件引入spring-context；
    • 使用<context:component-scan/>开启注解扫描（扫描被@Controller、@Service、@repository、@component等注解的类）；

  • @RequestMapping注解

　　　org.springframework.web.bind.annotation.RequestMapping注解类型指示Spring用哪一个类或方法来请求动作，该注解可用于类或方法
 
        @RequestMapping可以用来注释一个控制器类，在这种情况下，所有方法都将映射为相对于类级别的请求，如下：
@Controller
@RequestMapping(value="/user")
public class UserController{
       @RequestMapping(value="/register")
        public String register(){
            return "register";
        }
        @RequestMapping(value="/login")
        public String login(){
            return "login";
        }
}

由于UserController类中加了value="/user"的@RequestMapping注解，因此所有相关路径都要加上“/user”,此时方法被映射到如下请求：

http://localhost:8080/user/register

http://localhost:8080/user/login

    • @RequestMapping注解支持的常用属性
      • value属性：是@RequestMapping注解默认属性，若只有唯一属性，则可省略属性名
                　　    @RequestMapping(value="/hello")= @RequestMapping("/hello")
      • method属性：表明该方法仅处理的HTTP请求方式
                 　　　@RequestMapping(value="/hello",method=RequestMethod.POST),只支持post；如果没有指定method属性，则方法可以处理任意HTTP请求方式
      • consumes属性：表明处理请求的提交内容类型；
      • produces属性：表明返回的内容类型；
      • params属性:指定request中必须包含某些参数时，才让该方法处理；
      • headers属性：指定request中必须包含某些指定的header值，才让该方法处理请求；
    • 请求处理方法可以出现的参数类型（SpringMVC默认支持的参数，可出现可不出现，取决于是否用到）_Spring+Mybatis企业应用实战P30
      • HttpServletRequest对象
      • HttpServletResponse对象
      • HttpSession对象
      • Model对象
      • ModelMap对象
      • ......

  • @RequestParam注解

        org.springframework.web.bind.annotation.RequestParam注解类型用于将指定的请求参数赋值给方法中的形参
    • @RequestParam注解支持的常用属性
      • name：String类型；指定请求头绑定的名称
      • value：String类型；name属性的别名
      • required：boolean类型；指定参数是否必须绑定(默认值为true)；
      • defaultValue：String类型；如果没有传递参数而是用的默认值
@RequestMapping(value="/login")
public ModelAndView login(@RequestParam("loginname") String loginname,
                          @RequestParam("password") String password){
        return ......;
}

  • @PathVariable注解

        org.springframework.web.bind.annotation.PathVariable注解类型可以非常方便地获得请求URL的中的动态参数；
    • @PathVariable注解支持属性
      • value：String类型，表示绑定的名称，若省略则默认绑定同名参数
@RequestMapping(value="/pathVariableTest/{userId}")
public void pathVariableTest(@PathVariable Integer userId)

假如请求的URL为“http://localhost:8080/DataBindingTest/pathVariableTest/1”,则自动将URL中的模板变量{userId}绑定到通过@PathVariable注解的同名参数上，即userId变量将被赋值为1。

  • @RequestHeader注解

        org.springframework.web.bind.annotation.RequestHeader注解类型用于将请求的头信息区数据映射到功能处理方法的参数上
    • @RequestHeader注解支持的属性
      • name：String类型；指定请求头绑定的名称
      • value：String类型；name属性的别名
      • required：boolean类型；指定参数是否必须绑定；
      • defaultValue：String类型；如果没有传递参数而是用的默认值
@RequestMapping(value="/requestHeaderTest")
public void requestHeaderTest(@RequestHeader("User-Agent") String userAgent,
                              @RequestHeader(value="Accept") String[] accepts)

以上配置自动将请求头“User-Agent”的值赋到userAgent变量上，并将“Accept”请求头的值赋到accepts参数上

  • @CookieValue注解

        org.springframework.web.bind.annotation.CookieValue用于将请求的Cookie数据映射到功能处理方法的参数上
    • @CookieValue注解支持的属性
      • name：String类型；指定请求头绑定的名称
      • value：String类型；name属性的别名
      • required：boolean类型；指定参数是否必须绑定；
      • defaultValue：String类型；如果没有传递参数而是用的默认值
@RequestMapping(value="/cookieValueTest")
public void cookieValueTest(@CookieValue(value="JSESSIONID",defaultValue="") String sessionId)

以上配置会自动将JSESSIONID值设置到sessionId参数上，defaultValue表示Cookie中没有JSESSIONID时默认为空

  • @SessionAttributes注解（只能声明类，不能声明方法）

        org.springframework.web.bind.annotation.SessionAttributes注解类型允许我们有选择的指定Model中的哪些属性需要转存到HttpSession当中
    • @SessionAttributes注解支持的属性
      • names属性：String[]类型，Model中属性名称，即存储在HttpSession当中的属性名称；
      • value属性：String[]类型，names属性的别名；
      • types属性：Class<?>[]类型，用来指定放入HttpSession当中的对象类型
@Controller
//将Model中属性名为user的属性放入HttpSession对象当中
@SessionAttributes("user")
public class SessionAttributesController{
    
    @RequestMapping(value="/login")
    public String login(@RequestParam("loginname") String loginname,
                        @RequestParam("password") String password,
                        Model model){
         //创建User对象，装载用户信息
         User user = new User();
         user.setLoginname(loginname);
         user.setPassword(password);
         //将user对象添加到Model当中
         model.addAttribute("user",user);
         return "welcome";
    }
}

JSP页面测试以上@SessionAttributes注解：

${requestScope.user.username}//页面显示admin
${sessionScope.user.username}//页面显示admin

结论：User对象被成功设置到了HttpSession对象当中

@SessionAttributes注解如下写法： @SessionAttributes(types={User.class},value="user") 

还可以设置多个对象到HttpSession当中：

  • @ModelAttribute注解

        org.springframe.web.bind.annotation.ModelAttribute注解类型将请求参数绑定到Model对象
    • @ModelAttribute注解支持的属性（仅一个）
      • value属性：String类型，表示绑定的属性名称
        
　　  Notice：被@ModelAttribute注释的方法会在Cobtroller每个方法执行前被执行，因此在一个Controller映射到多个URL时，要谨慎使用！
　　  @ModelAttribute注解使用情况：
    • @ModelAttribute(value="")注释返回具体类的方法@ModelAttribute("loginname") public String userModel1(@RequestParam("logginname") String loginname){ return loginname; }
    • @ModelAttribute注释void返回值的方法 
      @ModelAttribute
public void userModel2(@RequestParam("loginname") String loginname,
                       @RequestParam("password") String password,
                       Model model){
    model.addAttribute("loginname",loginname);
    model.addAttribute("password",password);
}
    • @ModelAttribute注释返回具体类的方法 
      @ModelAttribute
public User userModel3(@RequestParam("loginname") String loginname,
                       @RequestParam("password") String password){
     return new User(loginname,password);
}
    • @ModelAttribute和@RequestMapping同时注释一个方法@RequestMapping(value="/login") @ModelAttribute(value="username") public String login4(){ return "admin"; }
    • @ModelAttribute注释一个方法的参数 
      @ModelAttribute("user")
public User userModel5(@RequestParam("loginname") String loginname,
                       @RequestParam("password") String password){
    User user = new User();
    user.setLoginname(loginname);
    user.setPassword(password);
    return user;
}
@RequestMapping(value="/login5")
public String login5(@ModelAttribute("user") User user){
    user.setUsername("管理员");
    return "result5";
}

      不管@ModelAttribute注解在什么情况下使用，model对象中的属性名都是@ModelAttribute的属性value值（有value存在情况下）或返回类型对象名（没有value存在情况下）；model对象中的值是方法返回值（有返回值情况下）或自己填充model（没有返回值情况下）

五、SpringMVC框架乱码解决方案

  • POST提交中文乱码解决

   　　在web.xml中添加过滤器: 
<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>

  • GET请求中文乱码解决（两种方法）

    • 修改tomcat配置文件添加编码与工程编码一致，如下： 
      <Connector URIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>
    • 对参数进行重新编码:String userName = new String(request.getParamter("userName").getBytes("ISO8859-1"),"utf-8")ISO8859-1是tomcat默认编码，需要将tomcat编码后的内容按utf-8编码

六、SpringMVC框架运转在执行handler（Controller）时，Spring会额外做一些工作：

  • 消息转换：将请求信息（如json、xml等数据）封装成一个对象，将对象转换为指定的相应信息；
  • 数据转换：对请求信息进行数据转换，如String转换成Integer、Double等；
  • 数据格式化：如将字符串转化成格式化数字或格式化日期；
  • 数据验证：验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中；
 
  • 特殊情况(解决日期类型参数转换问题):由于日期数据有很多种格式，所以springmvc没办法把字符串转换成日期类型。所以需要自定义参数绑定。前端控制器接收到请求后，找到注解形式的处理器适配器，对RequestMapping标记的方法进行适配，并对方法中的形参进行参数绑定。在springmvc这可以在处理器适配器上自定义Converter进行参数绑定。如果使用<mvc:annotation-driven/>可以在此标签上进行扩展。

　　   解决方案：

　　　　　　自定义转换器Converter

Public class DateConverter implements Converter<String, Date> {
      @Override
      public Date convert(String source) {
           SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
           try {
                 return simpleDateFormat.parse(source);
           } catch (ParseException e) {
                 e.printStackTrace();
           }
           Return null;
      }
}

　　　　　　配置Converter（在SpringMVC核心配置文件中）——第一种

<!-- 加载注解驱动 -->
      <mvc:annotation-driven conversion-service="conversionService"/>
      <!-- 转换器配置 -->
      <bean id="conversionService"
           class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
           <property name="converters">
                 <set>
                      <!-- 自己配置的日期转换器，如果还有其他转换器，可以继续在这里添加bean -->
                      <bean class="cn.itcast.spring mvc.convert.DateConverter"/>
                 </set>
           </property>
      </bean>

　　　　　　第二种配置方式：此方法需要独立配置处理器映射器、适配器，不再使用<mvc:annotation-driven/>

<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="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:dubbo="http://code.alibabatech.com/schema/dubbo"xmlns:mvc="http://www.springframework.org/schema/mvc"
      xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
http://code.alibabatech.com/schema/dubbohttp://code.alibabatech.com/schema/dubbo/dubbo.xsd
http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.0.xsd">
      <!-- 扫描带Controller注解的类 -->
      <context:component-scanbase-package="cn.itcast.springmvc.controller"/>
     
      <!-- 转换器配置 -->
      <beanid="conversionService"
           class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
           <propertyname="converters">
                 <set>
                      <beanclass="cn.itcast.springmvc.convert.DateConverter"/>
                 </set>
           </property>
      </bean>

      <!-- 自定义webBinder -->
      <beanid="customBinder" class="org.springframework.web.bind.support.ConfigurableWebBindingInitializer">
           <propertyname="conversionService"ref="conversionService"/>
      </bean>

      <!--注解适配器 -->
      <beanclass="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
           <propertyname="webBindingInitializer"ref="customBinder"></property>
      </bean>

      <!-- 注解处理器映射器 -->
      <beanclass="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
      
      <!-- 加载注解驱动 -->
      <!-- <mvc:annotation-driven/> -->

      <!-- 视图解析器 -->
      <beanclass="org.springframework.web.servlet.view.InternalResourceViewResolver">
           <propertyname="viewClass"
                 value="org.springframework.web.servlet.view.JstlView"/>
           <!-- jsp前缀 -->
           <propertyname="prefix"value="/WEB-INF/jsp/"/>
           <!-- jsp后缀 -->
           <propertyname="suffix"value=".jsp"/>
      </bean>
</beans>

 七、消息转换：将JSON、XML消息封装成对象，转换为相应的响应信息

  • @RequestBody注解

        org.springframework.web.bind.annotation.RequestBody注解用于读取Request请求的body部分数据，使用系统默认配置的HttpMessageConverter进行解析，然后把相应的数据绑定到Controller中方法的参数上；
        前台页面get或post提交数据时，数据编码格式由请求头的ContentType制定，可分以下情况：
    • application/x-www-form-urlencoded，这种情况的数据@RequestParam、@ModelAttribute也可以处理，@RequestBody也能处理(name1=value1&name2=value2........)
    • multipart/form-data，@RequestBody不能处理这种数据(有file处理时)
    • application/json、application/xml等格式数据，必须用@RequestBody处理     

  • 转换Json数据

     　Spring MVC提供了处理JSON格式请求/响应的HttpMessageConverter：MappingJackson2HttpMessageConverter。
　　 利用Jackson开源类包处理JSON格式的请求和响应消息（Spring官方说明，Spring MVC默认使用MappingJackson2HttpMessageConverter转换JSON格式数据，jackson开源类包可将java对象转换成json对象和xml文档，或逆转）
    • 示例：接收JSON格式的数据

　　　　　  JSP页面：

<%@ page language="java" contentType="text/html;charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
<title>测试接收JSON格式的数据</title>
<script type="text/javascript" src="js/jquery-1.11.0.min.js"/>
<script type="text/javascript" src="js/json2.js"/>
<script type="text/javascript">

$(document).ready(function(){
    testRequestBody();
});

function testRequestBody(){
    $.ajax("${pageContext.request.contextPath}/json/testRequestBody"//请求url
        {dataType:"json",    //预期服务器返回的数据类型
             type:"post",    //请求方式post或get
         contentType:"application/json"  //发送信息至服务器时的内容编码格式
         //发送到服务器的数据
         data:JSON.stringify({id:1,name:"Spring MVC企业应用实战"}),
         async:true,//默认设置下，所有请求为异步，若false，则发送同步请求
         //请求成功后的回掉函数
         success:function(data){
            console.log(data);
            $("#id").html(data.id);
            $("#name").html(data.name);
            $("#author").html(data.author);
          },
          //请求出错时调用的函数
          error:function(){
             alert("数据发送失败");
          }
    })；
}
</script>
</head>
<body>
编号：<span id="id"></apan>

书名：<span id="name"></span>

作者：<span id="author></span>

</body>
</html>

　　　　　　Controller：

@Controller
@RequestMapping("/json")
public class BookController{
    private static final Log logger = LogFactory.getLog(BookController.class);
    //@RequestBody根据json数据，转换成对应的Object
    @RequestMapping(value="/testRequestBody")
    public void setJson(@RequestBody Book book,
                        HttpServletResponse response) throws Exception{
        //ObjectMapper类是jackson库的主要类。他提供一些功能将java对象转换成对应的JSON格式数据
        ObjectMapper mapper = new ObjectMapper();
        //将book对象转换成为json输出
        logger.info(mapper.writeValueAsString(book));
          book.setAuthor("肖文姬");
        response.setContentType("text/html;charset=UTF-8");
        //将book对象转换成json写出到客户端
        response.getWriter().println(mapper.writeValueAsString(book));
    }
}

setJson方法的第一个参数@RequestBody Book book表示，使用@RequestBody注解获取到json数据后，将json数据设置到对应的book对象属性中去，参数response用于输出响应数据到客户端。

　　　　　　Book类：定义三个属性（id、name、author）

　　　　　　SpringMVC核心配置文件：

<!-- 注解扫描 -->
<context:component-scan base-package="org.fkit.controller"/>
<!-- 注解驱动 -->
<mvc:annotation-driven/>

<!-- 使用默认的Servlet来响应静态文件 -->
<mvc:default-servlet-handler/>

<!-- 视图解析器 -->
<bean id="viewResoler" class="org.springframework.web.servlet.view.InternalResourceViewResoler">
    <!-- 前缀 -->
    <property name="prefix">
        <value>/WEB-INF/content/</value>
    </property>
    <!-- 后缀 -->
    <property name="suffix">
        <value>.jsp</value>
    </property>
</bean>

<mvc:default-servlet-handler/>使用默认的Servlet来响应静态文件，因为在web.xml文件中使用了DispatcherServlet截获所有请求url，而引入<script type="text/javascript" src="js/jquery-1.11.0.min.js"/>的时候，DispatcherServlet会将“/”看成请求路径，找不到他的时候会报404错误。而当配置文件加上这个默认的Servlet时，Servlet在找不到它时会去找静态的内容，即js目录

    • 示例：自定义HttpMessageConverter接收JSON格式数据（不使用默认jackson开源类包）:说明：使用其他开源类包配置HttpMessageConverter（fastjson）

　　　　　　Controller:

@Controller
@RequestMapping("/json")
public class BookController{
    private static final Log logger = LogFactory.getLog(BookController.class);
    //@RequestBody根据json数据，转换成对应的Object
    @RequestMapping(value="/testRequestBody")
    public void setJson(@RequestBody Book book,
                        HttpServletResponse response) throws Exception{
        //JSONObject-lib包是一个beans,collections,maps,java arrays和xml和JSON互相转换的包

        //使用JSONObject将book对象转换成为json输出
        logger.info(JSONObject.toJSONString(book));
        book.setAuthor("肖文姬");
        response.setContentType("text/html;charset=UTF-8");
        //将book对象转换成json写出到客户端
        response.getWriter().println(JSONObject.toJSONString(book));
    }
}

　　　　　　Springmvc-config.xml(核心配置文件)：

<!-- 注解扫描 -->
<context:component-scan base-package="org.fkit.controller"/>

<!-- 注解驱动，摒弃默认配置HttpMessageConverter，自定义配置HttpMessageConverter -->
<mvc:annotation-driven>
    
    <!-- 设置不使用默认的消息转换器 -->
    <mvc:message-converter register-defaults="false">
        <!-- 配置Spring的转换器 -->
        <bean class="org.springframework.http.converter.StringHttpMessageConverter"/>
        <bean class="org.springframework.http.converter.xml.XmlAwareFormHttpMessageConverter"/>
        <bean class="org.springframework.http.converter.ByteArrayHttpMessageConverter"/>
        <bean class="org.springframework.http.converter.BufferedImageHttpMessageConverter"/>

        <!-- 配置fastjson中实现HttpMessageConverter接口的转换器 -->
        <!-- FastJsonHttpMessageConverter是fastjson中实现了HttpMessageConverter接口的类 -->
        <bean id="fastJsonHttpMessageConverter" class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
              <!-- 加入支持的媒体类型；返回contentType -->
              <property name="supportedMediaTypes">
                    <list>
                        <!-- 这里顺序不能反，一定先写text/html，不然IE下会出现下载提示 -->
                        <value>text/html;charset=UTF-8</value>
                        <value>application/json;charset=UTF-8</value>
                    </list>
              </property>
        </bean>
    </mvc:message-converter>

</mvc:annotation-driver>

<!-- 使用默认的Servlet来响应静态文件 -->
<mvc:default-servlet-handler/>

<!-- 视图解析器 -->
<bean id="viewResoler" class="org.springframework.web.servlet.view.InternalResourceViewResoler">
    <!-- 前缀 -->
    <property name="prefix">
        <value>/WEB-INF/content/</value>
    </property>
    <!-- 后缀 -->
    <property name="suffix">
        <value>.jsp</value>
    </property>
</bean>

本项目说明：自定义实现HttpMessageConverter时，关闭默认使用的MappingJackson2HttpMessageConverter消息转换器，不使用jackson开源类包，而是选择了更好的fastjson包，把转换器配置成FastJsonHttpMessageConverter类型，这个类实现了HttpMessageConverter接口；

 

JSP页面和java文件同上一个项目;

总结：由上两个项目可知：处理JSON格式的开源类包使用jackson和fastjson，只是HttpMessageConverter的实现不同；

  • @ResponseBody注解

         org.springframework.web.bind.annotation.ResponseBody注解用于将Controller的方法返回的对象，通过适当的消息转换器转为指定格式后，写入Response对象的body数据区。通常当返回的数据不是html标签页面，而是其他某种格式的数据时（如json、xml等）使用它。
    • 示例：返回JSON格式数据

　　　　　　Controller:

@Controller
@RequestMapping("/json")
public class BookController{
    @RequestMapping(value="/testResponseBody")
    //@ResponseBody会将集合数据转换为json格式并将其返回客户端
    @ResponseBody
    public Object getJson(){
        List<Book> list = new ArrayList<Book>();
        list.add(new Book(1,"Spring MVC 企业应用之战","肖文姬"));
        list.add(new Book(2,"轻量级javaee企业应用之战","李刚"));
        return list;
    }
}

　　　　　　JSP页面：

<%@ page language="java" contentType="text/html;charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
<title>测试返回JSON格式的数据</title>
<script type="text/javascript" src="js/jquery-1.11.0.min.js"/>
<script type="text/javascript" src="js/json2.js"/>
<script type="text/javascript">

$(document).ready(function(){
    testResponseBody();
});

function testResponseBody(){
    $.post("${pageContext.request.contextPath}/json/testResponseBody",null,
            function(data){
                $.each(data,function(){
                    var tr = $("<tr align='center'/>");
                    $("<td/>").html(this.id).appendTo(tr);
                    $("<td/>").html(this.name).appendTo(tr);
                    $("<td/>").html(this.author).appendTo(tr);
                    $("#booktable").append(tr);
                })
    },"json");
}
</script>
</head>
<body>
<table id="booktable" border="1" style="border-collapse:collapse;">
    <tr align="center">
        <th>编号</th>
        <th>书名</th>
        <th>作者</th>
    </tr>
</table>
</body>
</html>

  • 转换XML格式数据

    　  Spring MVC提供了处理XML格式请求/响应的HttpMessageConverter，如jaxb2RootElementHttpMessageConverter通过JAXB2读写XML消息，并将消息转换到注解@XmlRootElement和@XmlType作用的类中；
     　 Spring官方说明，Spring MVC默认使用了Jaxb2RootElementHttpMessageConverter转换xml格式数据，JAXB（Java Architecture for XML Binding）可以将JSON和XML互转；
      　JAXB是一项可以根据XML Schema产生Java类的技术，在过程中，JAXB提供了将XML实例文档反向生成Java对象的方法，并能将Java对象的内容重新写到XML文档中。
      　JAXB常用注解：@XmlRootElement、@XmlElement，等等
 
    • 示例：接收XML格式的数据

　　　　　　JSP页面：

<%@ page language="java" contentType="text/html;charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
<title>测试接收XML格式的数据</title>
<script type="text/javascript" src="js/jquery-1.11.0.min.js"/>
<script type="text/javascript" src="js/json2.js"/>
<script type="text/javascript">

$(document).ready(function(){
    sendXml();
});

function sendXml(){
    var xmlData = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><book><id>1</id><name>疯狂Java 讲义</name><author>李刚</author></book>";
    $.ajax("${pageContext.request.contextPath}/sendXml",//发送请求的URL字符串
            {
                type:"post",//请求方式post或get
                contentType:"application/xml",//发送信息至服务器时的内容编码类型
                //发送到服务器的数据
                data:xmlData,
                async:true,//默认设置下，异步请求；若false则发送同步请求
            });
}
</script>
</head>
<body>
</body>
</html>

　　　　　　Book类：

//@XmlRootElement表示XML文档的根元素
@XmlRootElement
public class Book implements Serializable{
    private Integer id;
    private String name;
    private String author;
    
    public Book(){
        super();
    }
    public Book(Integer id,String name,String author){
        this.id=id;
        this.name=name;
        this.author=author;
    }

    public Integer getId(){
        return id;
    }
    //该属性作为xml的element
    @XmlElement
    public void setId(Integer id){
        this.id=id;
    }
    public Integer getName(){
        return name;
    }
    //该属性作为xml的element
    @XmlElement
    public void setName(String name){
        this.name=name;
    }
    public Integer getAuthor(){
        return author;
    }
    //该属性作为xml的element
    @XmlElement
    public void setAuthor(String author){
        this.author =author ;
    }

    @Override
    public String toString(){
        return "Book[id="+id+",name="+name+",author="+author+"]";
    }
}

　　　　　　BookController:

@Controller
public class BookController{
    private static final Log logger = LogFactory.getLog(BookController.class);
    //@RequestBody会自动将xml数据绑定到Book对象
    @RequestMapping(value="/sendXml,method=RequestMethod.POST")
    public void sendXml(@RequestBody Book book){
        logger.info(book);
        logger.info("接收xml数据成功");
    }
    
    //@ResponseBody会将Book自动转换为xml数据返回
    @RequestMapping(value="/readXml",method=RequestMethod.POST)
    public @ResponseBody Book readXml() throws Exception{
        //通过JAXBContext的newInstance()方法，传递一个class就可以获得一个上下文
        JAXBContext context = JAXBContext.newInstance(Book.class);
        
        //创建一个Unmarshall对象
        Unmarshaller unmar = context.createUnmarshaller();
        InputStream is = this.getClass().getResourceAsStream("/book.xml");

        //Unmarshall对象的unmarshall方法可以进行xml到Java对象的转换
        Book book = (Book)unmar.unmarshall(is);
        logger.info(book);
        return book;
    }
}

springmvc-config.xml核心配置文件中注解驱动<mvc:annotation-driven/>,默认配置了jaxb2RootElementHttpMessageConverter作为转换器处理xml数据转换

    • 示例：返回xml格式数据

　　　　　　JSP页面：

<%@ page language="java" contentType="text/html;charset=UTF-8" 
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=UTF-8">
<title>测试接收XML格式的数据</title>
<script type="text/javascript" src="js/jquery-1.11.0.min.js"/>
<script type="text/javascript" src="js/json2.js"/>
<script type="text/javascript">

$(document).ready(function(){
    readXml();
});

function readXml(){
    $.ajax("${pageContext.request.contextPath}/readXml",//发送请求的URL字符串
            {
                dataType:"text",//预期服务器返回的数据类型
                type:"post",//请求方式post或get
                async:true,//默认设置下，异步请求；若false则发送同步请求
                success:function(xml){
                    //获得xml数据的id，name，author
                    var id=$("id",xml).text();
                    var name=$("name",xml).text();
                    var author=$("author",xml).text();
                    var tr = $("<tr align='center'/>");
                    $("<td/>").html(id).appendTo(tr);
                    $("<td/>").html(name).appendTo(tr);
                    $("<td/>").html(author).appendTo(tr);
                    $("#booktable").append(tr);
                },
                //请求出错时调用的函数
                error：function(){
                    alert("数据接收失败");
                }
            });
}
</script>
</head>
<body>
<table id="booktable" border="1" style="border-collapse:collapse;">
    <tr align="center">
        <th>编号</th>
        <th>书名</th>
        <th>作者</th>
    </tr>
</table>
</body>
</html>

 八、数据绑定流程（把请求数据 安全的，没有任何问题的 赋值给处理方法参数）

Spring MVC通过反射机制对目标处理方法的签名进行分析，并将请求信息绑定到处理方法的参数中。数据绑定的核心部件是DataBinder，其运行机制如下：

说明：Spring MVC框架将ServletRequest对象及处理方法的参数对象实例传递给DataBinder，DataBinder调用装配在Spring Web上下文中的ConversionService组件进行数据类型转换、数据格式化工作，并将ServletRequest中的消息填充到参数对象。然后再调用Validator组件对已经绑定了请求消息数据的参数对象进行数据合法性校验，并最终生成数据绑定结果BindingResult对象。BingdingResult对象包含已完成数据绑定的参数对象，还包含相应的校验错误对象，Spring MVC抽取BindingResult中的参数对象及校验错误对象，将他们赋给处理方法的相应参数。

九、数据转换（两种方式）

  • PropertyEditor接口（java所有）

    • 示例：使用@InitBinder添加自定义编辑器转换数据（局部）

　　　　　  Spring MVC在支持新的转换器框架的同时，也支持JavaBean的PropertyEditor

　　　　　  自定义属性编辑器DateEditor：

//自定义属性编辑器
public class DateEditor extends PropertyEditorSupport{
    //将传入的字符串数据转换成Date类型
    @Override
    public void setAsText(String text) throws IllegalArgumentException{
          SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
          try{
                Date date = dateFormat.parse(text);
                setValue(date);
          }catch(ParseException e){
                e.printStackTrace();
          }
    }
}

　　　　　  UserController:

//在控制器初始化时注册属性编辑器
@InitBinder
public void initBinder(WebDataBinder binder){                         
    //注册自定义编辑器                                           局部（仅在该控制器作用）
    binder.registerCustomEditor(Date.class,new DateEditor());
}
    • 示例：使用WebBindingInitializer注册全局自定义编辑器转换数据

 

　　　　　　DateBindingInitializer:

//实现WebBindingInitializer接口
public class DateBindingInitializer implements WebBindingInitializer{
    @Override
    public void initBinder(WebDateBinder binder,WebRequest request){
        //注册自定义编辑器
        binder.registerCustomEditor(Date.class,new DateEditor());
    }
}

　　　　　　UserController类不需要使用@InitBinder注解的方法，而是在springmvc-config.xml配置文件中配置全局的自定义编辑器

　　　　　　springmvc-config.xml:

<!-- 通过AnnotationMethodHandlerAdapter装配自定义编辑器 -->
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter">
    <property name="webBindingInitializer">
        <bean class="org.fkjava.binding.DateBindingInitializer"/>
    </property>
</bean>

  • ConversionService接口（spring所有）

    • org.springframework.core.convert.ConversionService是Spring类型转换的核心接口，接口中有4个方法
    • Spring在org.springframework.core.convert.converter包中定义了3种类型的转换器接口，使用时，只需实现其中任意一个接口，并将它作为自定义转换器注册到ConversionServiceFactoryBean当中。
      • Converter<S,T>接口：T  convert(S  source)：将S类型的对象转换为T类型的对象（常用）
      • ConverterFactory<S,R>接口：说明：将一种类型的对象转换为另一种类型及其子类对象，比如将String转换为Number以及Number子类Integer、double等对象，就需要一系列的Converter，如                                            StringToInteger、StingToDouble等。此接口的作用就是将相同系列多个Converter封装在一起。
        • <T   extends   R>   Converters<S,T>    getConverter(Class<T>  targetType)S为转换的源类型，R为目标类型的基类，T为R的子类。
      • GenericConverter接口：略
    • 示例：使用ConversionService转换数据

　　　　　　registerForm.jsp页面

<h3>注册页面</h3>
<form action="register" method="post">
    <table>
        <tr>
            <td><label>登录名：</label></td>
            <td><input type="text" id="loginname" name="loginname"></td>
        </tr>
        <tr>
            <td><label>生日：</label></td>
            <td><input type="text" id="birthday" name="birthday"></td>
        </tr>
        <tr>
            <td><input type="submit" id="submit" value="登陆"></td>
        </tr>
    </table>
</form>

　　　　　　JavaBean——User

public class User implements Serializable{
    private String loginname;
    private Date birthday;
    public User(){super();} 
    ...省略seter/geter...       
}

说明：User用于接收jsp页面传入的loginname和birthday属性，而jsp页面传入的数据都是String类型，分析出须将String转换为Date类型

　　　　　　UserController

@Controller
public class UserController{
    private static final Log logger = LogFactory.getLog(UserController.class);
    @RequestMapping(value="/{formName}")
    public String loginForm(@PathVariable String formName){
        //跳转动态页面
        return formName;
    }

    @RequestMapping(value="/register",method=RequestMethod.POST)
    public String register(@ModelAttribute User user,Model model){
        logger.info(user);
        model.addAttribute("user",user);
        return "success";
    }
}

异常原因：此时，在页面输入数据，点击登陆，由于页面传入的是字符串数据“2017-12-29”，而处理方法中的参数User对象的birthday属性类型是Date，因此此时会出现数据转换异常；

　　　　　　自定义转换器，将传递的字符串转换成Date类型

//实现Converter<S,T>接口
public class StringToDateConverter implements Converter<String,Date>{
    //日期类型模版：如yyyy-MM-mm
    private String datePattern;
    public void setDatePattern(String datePattern){
        this.datePattern = datePattern;
    }
    //Converter<S,T>接口的类型转换方法
    @Override
    public Date convert(String date){
        try{
            SimpleDateFormat dateFormat = new SimpleDateFormat(this.datePattern);
            //将日期字符串转换为日期返回
            return dateFormat.parse(date)；
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("日期转换失败");
            return null;
        }
    }
}

　　　　　　在springmvc-config.xml核心配置文件中加入自定义字符转换器

<!-- 装配自定义的类型转换器 -->
<mvc:annotation-driven conversion-service="convertionService"/>
<!-- 自定义的类型转换器 -->
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <list>
            <bean class="org.fkit.converter.StringToDateConverter" p:datePattern="yyyy-MM-dd"/>
        </list>
    </property>
</bean>

说明：<mvc:annotation-driven/>标签还会注册一个默认的ConversionService，即FormattingConversionServiceFactoryBean，以满足大多数类型转换的需求，现在需要注册一个自定义的StringToDateConverter转换类，因此，需要显示定义一个ConverterService覆盖<mvc:annotation-driven/> 中的默认实现类，这一步需要通过设置converters属性完成

　　　　　　success.jsp

<body>
登录名：${requestScope.user.loginname}//jack
生日：<fmt:formatDate value="${requestScope.user.birthday}" pattern="yyyy年MM月dd日"/>//2016年01月01日
</body>

  • 多种转换器的优先顺序

　　　@InitBinder装配的局部自定义编辑器——>spring的ConversionService装配的自定义转换器 ——>WebBinderInitializer接口装配的全局自定义编辑器

十、数据格式化

Spring使用Converter转换器进行源类型对象到目标类型对象的转换，Spring转换器并不承担输入以及输出信息格式化的工作，在不同的本地化环境中，同一类型的数据还会相应的呈现不同的显示格式。

Spring格式化框架：格式化数据（in）——>真正有用的数据——>格式化数据（out）；位于org.springframework.format包，其中最重要的接口是Formatter<T>接口；
  Converter Formatter
转换类型 任意Object——>任意Object 任意Object——>String
适用范围 Web层、service层、dao层 web层
建议
在Spring MVC的应用程序当中，如果向转换表单中的用户输入，
则建议使用Formatter，而不是Converter

　　　　

 

 

  • Formatter格式转换是Spring通过用的，定义在org.springframework.format包中，包中定义的接口有：

    • Printer<T>接口：格式化接口，其中T类型对象根据Locale信息以某种格式进行字符串格式输出
      • String print(T object,Locale locale)
    • Parser<T>接口：根绝Locale信息解析字符串到T类型对象。
      • T parse(String text,Locale locale) throws ParseException
    • Formatter<T>接口：格式化接口，继承自Printer<T>和Parser<T>接口，可以完成T类型对象的格式化和解析功能；
    • FormatterRegistrar接口：注册格式化转换器。该接口定义了一个registerFormatters方法，其参数是FormatterRegistry对象，用于注册多个格式化转换器。
      • void registerFormatters(FormatterRegistry registry)
    • AnnotationFormatterFactor<A extends Annotation> y接口：略

  • 使用Formatter格式化数据

　　　自定义格式化转换器DateFormatter:

//实现Formatter<T>接口
public class DateFormatter implements Formatter<Date>{
    //日期类型模板：如：yyyy-MM-dd
    private String datePattern;
    //日期格式化对象
    private SimpleDateFormat dateFormat;
    //构造器，通过依赖注入的日期类型创建日期格式化对象
    public DateFormatter(String datePattern){
        this.datePattern = datePattern;
        this.dateFormat = new SimpleDateFormat(datePattern);
    }

    //显示Formatter<T>的T类型对象
    @Override
    public String print(Date date,Locale locale){
        return dateFormat.format(date);
    }

    //解析文本字符串，返回一个Formatter<T>的T类型对象
    @Override
    public Date parse(String source,Locale locale){
        try{
            return dateFormat.parse(source);
        }catch(Exception e){
            e.printStackTrace();
            throw new IllegalArgumentException();
        }
    }
}

说明：DateFormatter类实现了org.springframework.format.Formatter接口，实现了接口中的两个方法：parse()和print()；日期类型模板会通过配置文件的依赖注入设置

　　　在springmvc-config.xml中加入自定义的格式化转换器：

<!-- 装配自定义格式化转换器 -->
<mvc:annotation-driven conversion-service="conversionService"/>

<!-- 格式化转换器 -->
<bean id="conversionService"                                                                                       class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
    <property name="formatters">
        <list>
            <bean class="org.fkit.formatter.DateFormatter" c:_0="yyyy-MM-dd"/>
        </list>
    </property>
</bean>

说明：以上配置使用FormattingConversionServiceFactoryBean对自定义的格式转换器DateFormatter进行了注册。FormattingConversionServiceFactoryBean类有一个属性converters，可以用它注册Converter；有一个属性formatters，可以用它注册Formatter

以上使用实现Formatter<T>接口的方式完成转换数据

 Spring提供了很多常用的Formatter实现。对于这些实现类，不需要自定义转换功能，只需要在springmvc-config.xml配置文件中配置好就能用：
  • 在org.springframework.format.datetime包中
    • DateFormatter：用于时间对象格式化
  • 在org.springframework.format.number包中
    • NumberFormatter:用于数字类型对象格式化
    • CurrencyFormatter：用于货币类型对象格式化
    • PercentFormatter：用于百分数数字类型对象格式化
例如：使用org.springframework.format.datetime包中的DateFormatter完成字符串到日期对象的转化，如下配置即可：
在springmvc-config.xml中加入自定义的格式化转换器： 
<!-- 装配自定义格式化转换器 -->
<mvc:annotation-driven conversion-service="conversionService"/>

<!-- 格式化转换器 -->
<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
    <property name="formatters">
        <list>
            <bean class="org.springframework.format.datetime.DateFormatter" p:pattern="yyyy-MM-dd"/>
        </list>
    </property>
</bean>

  • 使用AnnotationFormatterFactory<A extends Annotation>格式化数据

　　　Spring为开发者提供了注解驱动的属性对象格式化功能：在Bean属性中设置、Spring MVC处理方法参数绑定数据、模型数据输出时自动通过注解应用格式化的功能

　　　在org.springframework.format.annotation包下面定义了两个格式化的注解类型：

    • DateTimeFormat
       　　　 @DateTimeFormat注解可以对java.util.Date、java.util.Calendar等时间类型的属性进行标注；它支持一下几个互斥的属性。具体说明如下：
      • iso。类型为DateTimeFormat.ISO。以下几个常用可选值：
        • DateTimeFormat.ISO.DATE:格式为yyyy-MM-dd
        • DateTimeFormat.ISO.DATE_TIME:格式为yyyy-MM-dd hh:mm:ss.SSSZ
        • DateTimeFormat.ISO.TIME:格式为hh:mm:ss.SSSZ
        • DateTimeFormat.ISO.NONE:表示不使用ISO格式的时间
      • pattern。类型为String，使用自定义的时间格式化字符串，如“yyyy-MM-dd hh:mm:ss”
      • style。
    • NumberFormat
       　　　 @NumberFormat可对类似数字类型的属性进行标记，他有两个互斥属性，具体如下：
      • pattern。类型为String，使用自定义的数字格式化串，如“##，###。##”
      • style。类型为NumberFormat.Style,以下常用可选值：
        • NumberFormat.CURRENCY:货币类型
        • NumberFormat.NUMBER:正常数字类型
        • NumberFormat.PERCENT:百分数类型

　　　testForm.jsp:

<h3>测试表单数据格式化</h3>
<form action="test" method="post">
    <table>
        <tr>
            <td><label>日期类型：</label></tr>
            <td><input type="text" id="birthday" name="birthday"/></td>
        </tr>
        <tr>
            <td><label>整数类型：</label></tr>
            <td><input type="text" id="total" name="total"/></td>
        </tr>
        <tr>
            <td><label>百分数类型：</label></tr>
            <td><input type="text" id="discount" name="discount"/></td>
        </tr>
         <tr>
            <td><label>货币类型：</label></tr>
            <td><input type="text" id="money" name="money"/></td>
        </tr>
         <tr>
            <td><input type="submit" value="提交"/></td>
        </tr>
    </table>
</form>

　　　User——注解：

public class User implements Serializable{
    //日期类型
    @DateTimeFormat(pattern="yyyy-MM-dd")
    private Date birthday;

    //正常数字类型
    @NumberFormat(style=Style.NUMBER,pattern="#,###")
    private int total;

    //百分数类型
    @NumberFormat(style=Style.PERCENT)
    private double discount;

    //货币类型
    //@NumberFormat(style=Style.CURRENCY)
    private double money;

    .....省略set/get方法
}

说明：User类的多个属性使用了DateTimeFormat和NumberFormat注解，用于将页面传递的String转换成对应的格式化数据；

　　　UserController：

@Controller
public class FormatterController{
    private static final Log logger = LogFactory.getLog(FormatterController.class);

    @RequestMapping(value="/{formName}")
    public String loginForm(@PathVariable String formName){
        //动态跳转页面
        return formName;
    }

    @RequestMapping(value="/test" method=RequestMethod.POST)
    public String test(@ModelAttribute User user,Model model){
        logger.info(user);
        model.addAttribute("user",user);
        return "success";
    }
}

　　　success.jsp页面：

<%@ taglib prefix="form" url="http://www.springframework.org/tags/form" %>
<h3>测试表单数据格式化</h3>
<form:form modelAttribute="user" method="post" action="" />
    <table>
        <tr>
            <td>日期类型：</td>
            <td><form:input path="birthday"/></td>
        </tr>
        <tr>
            <td>整数类型：</td>
            <td><form:input path="total"/></td>
        </tr>
        <tr>
            <td>百分数类型：</td>
            <td><form:input path="discount"/></td>
        </tr>
        <tr>
            <td>货币类型：</td>
            <td><form:input path="money"/></td>
        </tr>
    </table>

注意：如果希望在视图页面中将模型属性数据以格式化的方式进行渲染，则需使用Spring的页面标签显示模型数据。所以在success.jsp中受用了<form:form modelAttribute="user">标签，并且绑定了user对象

　　　springmvc-config.xml: <!-- 默认装配 --> <mvc:annotation-driven/> 

说明：默认配置注解驱动，则也是默认创建了ConversionService实例FotrmattingConversionServiceFactoryBean，这样就可以支持注解驱动的格式化功能了


原文链接:https://www.cnblogs.com/wly1-6/p/10401594.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：EditText搜索关键字，返回结果匹配关键字改变颜色

下一篇：java基础(五)-----关键字static

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签