SSM框架的简单汇总笔记

spring 的注解：

    @Component 组件注解，代表一般组件 （ @Named 通用注解）
    @Repository 持久化组件的注解
    @Service 业务层注解
    @Controller 控制层注解
    @Scope("prototype") 作用域 ，默认是singleton
    @PostConstruct 初始化回调注释
    @PreDestroy 销毁回调
    @Resource 自动注入 

配置文件中的依赖注入（ref）

    <bean id="c3p0DataSource"
    class="com.mchange.v2.c3p0.ComboPooledDataSource"
    destroy-method="close">
        <property name="driverClass" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/wjh"/>
        <property name="user" value="root" />
        <property name="password" value="root" />
    </bean>
    <bean id="jdbcTemplate"  class="org.springframework.jdbc.core.JdbcTemplate">
            <property name="dataSource" ref="c3p0DataSource"/>
    </bean>

静态工厂和实例工厂

1.静态工厂

    <bean id="userService" factory-method="getUserService" class="factory.StaticFactory" />

2.实例工厂

    <bean id="beanFactory" class="factory.BeanFactory"/>
    <bean id="userService" factory-method="getUserService" factory-bean="beanFactory"/>

指定依赖注入

    @Autowired
    public void setName( @Qualifier("name") String name){ //name不能可以省略
        Logger logger = Logger.getLogger(this.getClass());
        logger.warn(name);
    }

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



    <bean id="name" class="java.lang.String">
        <constructor-arg value="王建杭"/>
    </bean>

    @Resource //也可以直接放在属性上面
    public void setDao(DemoDao demoDao){
        this.demoDao = demoDao;
    }

    @Resource（name="demoDao"）
    public void setDao(DemoDao demoDao){
        this.demoDao = demoDao;
    }

@Resource只支持单个项目，不支持聚合项目

构造方法注入

    @Autowired
    public Demo( @Qualifier("b") String a,@Qualifier("b") String b) {
        System.out.println(a);
        System.out.println(b);

    }

自动注入，找demoDao的id

    //id是demoDao
    @Repository
    public class DemoDao {

    //id是demo
    @Repository("demo")
    public class DemoDao {

引入配置文件，动态配置属性

<!-- 引入外部文件 -->
    <context:property-placeholder location="classpath:user.properties" />

user.properties

    age=18
    name=jack
User.java

    @Value("${age}")
    private Integer age;

    @Value("${name}")
    private String name;


###工具类的使用


    <util:list id="list">
        <value>1</value>
        <value>2</value>
        <value>3</value>        
    </util:list>

    @Value("#{@list}")
    private List<Object> list;

spring-mvc四大组件

1.前端控制器(DispatcherServlet)

作用 ：负责request对象和response对象的转发和响应。

2.处理映射器

匹配处理请求的类，交个给前端控制器。

3.处理器适配器

调用适当的处理器去执行请求

4.视图解析器

根据返回的页面名称为其拼接真实的路径

web.xml配置

 <!-- springMVC servlet -->
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>*.html</url-pattern>
    </servlet-mapping>

    <!-- spring mvc 乱码过滤器 -->
    <filter>
        <filter-name>encodingFilter</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>encodingFilter</filter-name>
        <url-pattern>*.html</url-pattern>
    </filter-mapping> 

spring-mvc.xml配置文件：

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


        <!-- 包扫描器 -->
        <context:component-scan base-package="spring"/>  
        <!-- 视图转发器 前缀是 /jsp/  后缀是 .jsp -->
        <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
            <property name="prefix" value="/jsp/"/> 
            <property name="suffix" value=".jsp"/>
        </bean>

        <!-- 登陆检测,拦截器 ，过滤器的子类-->
        <mvc:interceptors>
            <mvc:interceptor>
                <mvc:mapping path="/article/*"/>
                <mvc:exclude-mapping path="/user/*"/>
                <bean class="interceptor.LoginInterceptor"/>
            </mvc:interceptor>
        </mvc:interceptors>


        <!-- 上传组件 -->
        <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
            <property name="maxUploadSize" value="10240" />
            <property name="resolveLazily" value="true" />
        </bean>
        <!-- 开启注解映射 -->
        <mvc:annotation-driven/>

      <!--   
        配置文件中配置 url映射,不建议使用
        <bean id="helloController" class="spring.controller.HelloWorldController"/>
        <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
            <property name="mappings">
                <props>
                    <prop key="/hello.html">helloController</prop>
                </props>
            </property>
        </bean> -->

    </beans>



###spring mvc 加载多个配置文件

    <context-param>  
        <param-name>contextConfigLocation</param-name>  
        <param-value>  
            /WEB-INF/classes/applicationContext-*.xml，
            classpath:applicationContext-*.xml
        </param-value>  
    </context-param>  


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

控制器的配置

package spring.controller;

    import java.io.IOException;

    import javax.servlet.http.HttpServletResponse;

    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;

    @Controller
    @RequestMapping("/user")//这种方法忽略后缀
    public class UserController { //控制器，/user是映射路径

        @RequestMapping("/login") //此方法的映射路径是 /user/login
        public void login(HttpServletResponse res) throws IOException{
            res.getWriter().println("login~");
        }

        @RequestMapping("/login") //注入参数
        public void login(@RequestParam("id") int id) throws IOException{
            res.getWriter().println("login~");
        }

    }



    //转发到/jsp/test.jsp
    @RequestMapping(value="/test")
    public String test(HttpServletRequest req){

        return "test"; 
    }


    //重定向 到/jsp/test.jsp
    @RequestMapping(value="/test2")
    public String test2(){

        return "redirect:test"; 
    }

    //接收一个model

    @RequestMapping("/test2")
    public String test2(Model model){
        model.addAttribute("msg", "hello");
        return "redirect:/user/test.do"; 
    }

model内的数据以get方式提交过去

拦截器的配置

spring-mvc.xml 配置

    <!-- 登陆检测,拦截器 ，过滤器的子类-->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/article/*"/>
            <mvc:exclude-mapping path="/user/*"/>
            <bean class="interceptor.LoginInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

代码如下：

package interceptor;

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

    import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.ModelAndView;

    public class LoginInterceptor implements HandlerInterceptor {

        @Override
        public void afterCompletion(HttpServletRequest req,
                HttpServletResponse res, Object handler, Exception ex)
                throws Exception {


        }

        @Override
        public void postHandle(HttpServletRequest req, HttpServletResponse res,
                Object handler, ModelAndView mv) throws Exception {


        }

        @Override
        public boolean preHandle(HttpServletRequest req, HttpServletResponse res,
                Object handler) throws Exception {

        /*  HttpSession session = req.getSession();
            String loginId = (String) session.getAttribute("loginId");
            if(loginId == null){
                return false;
            }
            return true;*/
            return true;
        }

    }

异常处理

@ExceptionHandler //异常处理的注解，如果在一个控制器中只针对这个控制器抛出的异常有效
    public String doException(MaxUploadSizeExceededException ex,Model model){
        model.addAttribute("message", "文件应该要小于"+ex.getMaxUploadSize()+"字节");
        return "upload/upload";
    }

多个异常的处理

@ExceptionHandler({MaxUploadSizeExceededException.class,NumberFormatException.class})
    @ResponseBody
    public String doException(Exception ex,Model model){

        //model.addAttribute("message", "文件应该要小于"+ex.getMaxUploadSize()+"字节");
        return ex.getClass().toString();
    }

全局异常处理

package spring.global;

    import org.apache.log4j.Logger;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;

    @ControllerAdvice //这个类中的ExceptionHandler会捕获所有控制器抛出的异常
    public class GlobalHandler{
        private Logger logger = Logger.getLogger(this.getClass());

        @ExceptionHandler(Exception.class)
        public String doException(Exception ex){
            logger.error(ex.getMessage(),ex);
            return "error/exception";
        }


    }

@ControllerAdvice 注解

1. 通过@ControllerAdvice注解可以将对于控制器的全局配置放在同一个位置。
2. 注解了@Controller的类的方法可以使用@ExceptionHandler、@InitBinder、@ModelAttribute注解到方法上。
3. @ControllerAdvice注解将作用在所有注解了@RequestMapping的控制器的方法上
4. @ExceptionHandler：用于全局处理控制器里的异常。
5. @InitBinder：用来设置WebDataBinder，用于自动绑定前台请求参数到Model中。
6. @ModelAttribute：本来作用是绑定键值对到Model中，此处让全局的@RequestMapping都能获得在此处设置的键值对。

代码：

@ControllerAdvice
    public class AdviceControlller {

        private Logger logger = Logger.getLogger(this.getClass());

        //异常处理
        @ExceptionHandler(Exception.class)
        public String doException(Exception ex){
            logger.error(ex.getMessage(),ex);
            return "error/exception";
        }

        //参数转换
        @InitBinder
        public void InitBinder (ServletRequestDataBinder binder){
            binder.registerCustomEditor(
            java.util.Date.class, 
            new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), true));
        }


    }

@ModelAttribute  的使用

    @ModelAttribute  
    public void populateModel(@RequestParam String abc, Model model) {  
       model.addAttribute("attributeName", abc);  
    }  


    @ModelAttribute("attributeName")  
    public String addAccount(@RequestParam String abc) {  
       return abc;  
    }  


    public String test1(@ModelAttribute("user") UserModel user)  

log4j的整合

log4j.properties文件内容(在控制台打印输出的配置)：

    log4j.rootLogger=all,console
    log4j.appender.console.threshold=warn
    log4j.appender.console=org.apache.log4j.ConsoleAppender
    log4j.appender.console.target=System.err
    log4j.appender.console.immediateFlush=true
    log4j.appender.console.layout=org.apache.log4j.PatternLayout
    log4j.appender.console.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss}-[%p]-[%l]:%m%n
    #log4j.appender.console.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss}-[%c]-[%p]-[%l]:%m%n

在web.xml中：

    <!-- log4j配置 ， -->
    <context-param>
        <param-name>log4jConfigLocation</param-name>
        <param-value>/WEB-INF/props/log4j.properties</param-value>
    </context-param>

    <!-- 6秒扫描一次配置文件的改动,会导致log4j无法关闭[FileWatchdog]线程  -->
    <context-param>
        <param-name>log4jRefreshInterval</param-name>
        <param-value>6000</param-value>
    </context-param>


    <!-- log4j 监听器 -->
    <listener>
        <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
    </listener>

log4j的使用

Logger logger = Logger.getLogger(this.getClass());
    logger.warn("log4j输出");

控制台打印示例：
2017-05-26 10:14:53-[WARN]-[spring.controller.GlobalController.do404(GlobalController.java:18)]:log4j输出

文件上传：

在springmvc.xml中

<!-- 上传组件 -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="10240" /> //最大1024个字节
        <property name="resolveLazily" value="true" /> //懒汉式加载，可进行异常获取
    </bean>

在程序中：

 @RequestMapping("/upload")
    public String upload(MultipartFile file, //当文件上传时 用数组接收即可 (MultipartFile[] file)
            HttpServletRequest res,ModelMap model) throws IOException{
        if(file == null){
            model.addAttribute("message", "文件为空");
            return "/upload/upload";
        }
        String path = res.getSession().getServletContext().getRealPath("upload");
        String fileName = file.getOriginalFilename();
        File uploadFile = new File(path,fileName);
        file.transferTo(uploadFile);
        model.addAttribute("fileName", fileName);
        return "/upload/res";
    }

当上传的文件大于配置的字节时，需要配置一个异常处理方法

@ExceptionHandler
    public String doException(MaxUploadSizeExceededException ex,Model model){
        model.addAttribute("message", "文件应该要小于"+ex.getMaxUploadSize()+"字节");
        return "upload/upload";
    }

404错误的处理的解决方法，配置一个通配的控制器

package spring.controller;

    import javax.servlet.http.HttpServletRequest;

    import org.apache.log4j.Logger;
    import org.springframework.stereotype.Controller;
    import org.springframework.ui.Model;
    import org.springframework.web.bind.annotation.RequestMapping;

    @Controller
    @RequestMapping("**")//通配控制器，匹配所有的匹配不上其他映射路径的路径（一个*代表一层路径，**代表多层路径）
    public class AlllController {

        @RequestMapping("")//默认匹配
        public String do404(HttpServletRequest req,Model model){
            model.addAttribute("url", req.getRequestURL());
            Logger logger = Logger.getLogger(this.getClass());
            logger.warn("log4j输出");
            return "error/404";
        }

    }

定义一个异常：可以指定状态，前提是这个异常不能被捕获，这个需要被抛给服务器

    @ResponseStatus(value=HttpStatus.NOT_FOUND,reason="demoException")
    public class DemoException extends RuntimeException {

不转发jsp，直接输出字符串

@RequestMapping(value="/other",produces="text/html;charset=UTF-8") 
    @ResponseBody //浏览器收到"other"字符串
    public String other(){
        Logger logger = Logger.getLogger(this.getClass());
        logger.warn("other");
        return "other";
    }

    @RequestMapping(value="/other",produces="text/html;charset=UTF-8") 
    @ResponseBody //浏览器收到"other"字符串
    public void other(){
        Logger logger = Logger.getLogger(this.getClass());
        logger.warn("other");
        res.getWriter().print("abc");
    }

关于json的配置和使用

需要2个jar包 :

1. jackson-mapper-asl-1.9.13.jar
2. jackson-core-asl-1.9.13.jar

  @RequestMapping(value="a" ,produces="application/json;charset=UTF-8")
        public  @ResponseBody User a() {
            User user = new User();
            user.setAge(11);
            user.setName("小红");
            return user;
        }

produces：请求的是json，并且以json为后缀,浏览器以.html为后缀中会接收text/html类型

在web.xml中需要配置2个映射

    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>*.html</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/server/*</url-pattern>
    </servlet-mapping>


    function send(){
        $.ajax({
            "url" : "server/hello/a.json",
            "contentType":"application/json;charset=UTF-8",
            "async" : true,
            "type" : "POST",
            "success" : function(result){
                var name = result.name;
                $("#msg").html("<font style='color:red'>"+name+"</font>")
            }
        });
    }

springMVC4.2的不支持1.x的jackson的，会报HttpMediaTypeNotAcceptableException：Could not find acceptable representation
没有匹配类型，其实是使用了MappingJackson2HttpMessageConverter.class类，这个类支持2.x的jackson,只能使用3.2的spring

jackson 1.x jar包

• jackson-mapper-asl-1.9.13.jar
• jackson-core-asl-1.9.13.jar6

spring-mvc 4.2 可以使用下面的扩展包

jackson2.x用下面的包

• jackson-annotations-2.4.0.jar
• jackson-core-2.4.2.jar
• jackson-databind-2.4.2.jar

REST(RESTful)概念

可提高伸缩性，降低耦合度便于分布式处理程序

RESTful 规范：

http://localhost:8080/web/delUser/1234

http://localhost:8080/web/orders/2017/06/18434

• POST: Create Delete Update
• GET:Read
• PUT:Update Create

• DELETE:Delete

• /blog/1 http GET => 查询id=1的blog

• /blog/1 http DELETE => 查删除id=1的blog
• /blog/1 http PUT => 更新 id=1的blog
• /blog/add http POST => 新增blog

spring对REST的支持

• @RequestMapping 指定要处理请求的URI方法和HTTP的请求动作
• @PathVariable 将URI中请求模板中的变量映射到处理方法的参数上
• 利用Ajax,可以在浏览器中发送PUT和Delete的请求

在控制器中

@RequestMapping("/rest/{id}")
    public @ResponseBody  String rest(@PathVariable int id){

        logger.info(id);

        return "rest";
    }

指定方法和指定path参数名

@RequestMapping(value="/rest/{id}",method=RequestMethod.GET)
    public @ResponseBody  String rest(@PathVariable("id") int i){
        logger.info(i);
        return "rest";
    }

静态资源的访问控制

<!-- 静态资源访问 -->
    <mvc:resources location="/jsp/"   mapping="/jsp/*"/>
    <mvc:resources location="/image/"   mapping="/image/*"/>
    <mvc:resources location="/css/"   mapping="/css/*"/>
    <mvc:resources location="/js/"   mapping="/js/*"/>

    <!--默认的资源访问控制-->
    <!-- <mvc:default-servlet-handler/> -->

自动封装javaBean

    @RequestMapping("/addUser")
    public @ResponseBody String addUser(User user){

        //logger.info(user);
        if(user != null)
            return user.toString();
        return "user is null";
    }


    <form action="demo/addUser" method="post">
        <input type="text" name="email" value="293@qq.com" >
        <input type="text" name="password" value="123">
        <input type="text" name="nickname" value="jack">
        <input type="submit" value="注册" >
    </form>

多个javaBean封装

@RequestMapping("/addUser")
    public @ResponseBody String addUser(User user,UserInfo info){

        //logger.info(user);
        if(user == null)
            return "user is null";
        if(info == null)
            return "info is null";
        return user.toString()+"|"+info.toString();
    }

    <form action="demo/addUser" method="post">
        <input type="text" name="email" value="293@qq.com" >
        <input type="text" name="password" value="123">
        <input type="text" name="nickname" value="jack">
        <input type="text" name="age" value="18">
        <input type="text" name="sex" value="man">
        <input type="submit" value="注册" >
    </form>

1. html中提交的字段会自动封装成User实体对象，自动匹配属性，没有的值则为空
2. 也可以直接注入User实体对象的引用，如：name=”type.name”就可以为user中的type对象的name进行注入
3. 封装对象会被放入model中，转发到页面中可以直接使用之前提交过去的数据，如：

代码如下：

<input type="text" name="email" value="${user.email}" >//user不可省略

    <input type="text" name="type.name" value="${user.type.name}" >

传递参数的类型转换

@InitBinder
    public void InitBinder (ServletRequestDataBinder binder){
        binder.registerCustomEditor(
        java.util.Date.class, 
        new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), true));
    }

spring的测试方法

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = "classpath:applicationTest.xml")
    public class Demo {

        @Resource
        private TestDao testDao;

        @Test
        public void demo1() {
            testDao.print();
        }
    }