zoukankan      html  css  js  c++  java
  • SpringMvc上手学习

    项目位置:D: ingxinjiecodespringmvc-study

    1基本组件

    image-20201120093404963

    2流程分析

    springmvc基本最清晰的流程分析

    image-20201120093249565

    流程:前端控制器控制/请求,也就是全部请求来了都走进前端控制器(在servlet-mapping中设置),然后用户发送/hello请求,因为属于前端控制器的范围,因此它会响应用户的请求

    3.详细的流程

    image-20201120094359940

    image-20201120095747540

    现在的版本中,开启注解支持,默认帮我们导入处理映射器与处理适配器,因此我们只要定义:

    • 前端控制器

    • 视图解析器

    就能执行,这就是原因

    <!--开启springmvc注解支持 RequestMapping这些就是开启才会生效的(默认自带处理映射器与处理适配器)-->
    <mvc:annotation-driven/>

     

    请求参数绑定在Spring mvc中十分简单,我们只需要将方法的名字和请求的参数的key相同即可绑定成功

    请求绑定在Spring mvc中十分简单,只需要请求参数名字和方法名相同即可

    如果是对象,使用表单name值和字段名相同即可 如果对象中还有对象,则使用user.uName 这样的name即可

        <form action="param/testParam2" method="post">
           <%--类中的属性--%>
           <input name="username" placeholder="姓名"/>
           <input name="password" type="password" placeholder="密码">
           <input name="money" placeholder="账户金额">
               
           <%--对象--%>
           <input name="user.uName" placeholder="用户名">
               
           <%--list--%>
           <input name="list[0].uName" placeholder="第一个list字段"/>
           <input name="list[1].uName" placeholder="第一个list字段"/>
               
           <%--map--%>
           <input name="map['one'].uName" placeholder="第一个map字段"/>
           <input name="map['two'].uName" placeholder="第二个map字段"/>
               
           <button type="submit">提交</button>
       </form>

    4.过滤器

    用于解决post乱码问题,我们可以使用过滤器

      <!--配置过滤器-->
     <filter>
       <filter-name>characterEncodingFilter</filter-name>
       <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
       <init-param>
         <param-name>encoding</param-name>
         <param-value>UTF-8</param-value>
       </init-param>
     </filter>
     
     <filter-mapping>
       <filter-name>characterEncodingFilter</filter-name>
       <url-pattern>/*</url-pattern>
     </filter-mapping>

    拦截器

    image-20201121114051875

    区别在上图中已经讲得很明显了:

    1.过滤器是servlet一部分,任何java web都可以用,而拦截器是springmvc自己的,只有springmvc框架才能使用

    2.过滤器在url-pattren中配置了/*之后,可以对所有要访问的资源拦截,比如说包括controller,或者jsp,html,js等等

    3.但是拦截器只会拦截控制器的方法,对于其他的资源是不会拦截的

    总而言之:拦截器是springmvc特有的,它只拦截controller的方法 而过滤器是servlet的规范,它过滤配置路径下的一切资源

    image-20201121114353910

     

    5.自定义类型转换器

    因为date自动装配的时候,只要按照指定格式才能自动装配成功,否则报400客户端的错误,这时候就需要自定义类型转换器来实现我们的功能。

    5.1实现Converter接口
    import org.springframework.core.convert.converter.Converter;

    public class String2DateConverter implements Converter<String, Date> {
       @Override
       public Date convert(String s) {
           if(s==null)return null;

           DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
           try {
               return dateFormat.parse(s);
          } catch (ParseException e) {
               e.printStackTrace();
          }
           return null;
      }
    }
    5.2配置自定义的类型转换器
    <!--类型转换器-->
    <bean id="conversionServiceFactoryBean" class="org.springframework.context.support.ConversionServiceFactoryBean">
       <property name="converters" ref="string2DateConverter"/>
    </bean>
    <bean id="string2DateConverter" class="com.jd.nxj.utils.String2DateConverter"/>
    5.3在这里加入配置,代表自定义类型转换器
    <!--开启springmvc注解支持 RequestMapping这些就是开启才会生效的(默认自带处理映射器与处理适配器)-->
    (这个注解默认处理映射器与处理适配器生效,但是类型转换器并没有默认生效,因此我们在这里配置一下)
    <mvc:annotation-driven conversion-service="conversionServiceFactoryBean"/>

    6获取Servlet原生API

     <a href="param/testServlet">获取原生API只需要在方法参数中加上即可</a>
    //获取原生API
    @RequestMapping("/testServlet")
    public String testServlet(HttpServletRequest request, HttpServletResponse response){
       System.out.println("获取原生API...");
       HttpSession session = request.getSession();
       ServletContext servletContext = session.getServletContext();
       System.out.println(session);
       System.out.println(servletContext);
       System.out.println(response.getHeaderNames());
       return "success";
    }

    7常用注解

    image-20201120170841600

    7.1 RequestParam

    说明:自动装配的名字和我参数名不同,我可以通过这个注解指定

    <a href="testRequestParam?n=nxj">RequestParam</a>
    @RequestMapping("/testRequestParam")
    public String testRequestParam(@RequestParam("n") String name){
       System.out.println(name);
       return "success";
    }
    7.2 RequestBody

    image-20201120175248835

    @RequestMapping("/testRequestBody")
    public String testRequestBody(@RequestBody String body){
       System.out.println(body);//user=nxj&pass=123
       return "success";
    }
    <form action="testRequestBody" method="post">
      姓名:<input name="user"/><br/>
      密码:<input name="pass"/><br/>
       <input type="submit" value="提交"/>
    </form>
    7.3 PathVaraible
    <a href="testPathVariable/nxj">PathVariable</a>
    @RequestMapping("/testPathVariable/{user}")
    public String testPathVariable(@PathVariable("user") String user){
       System.out.println(user);
       return "success";
    }
    如何发出POST,DELETE等请求方式

    (这个不用急,配置比较麻烦,以后需要用的时候百度一下就好)

    image-20201120183132322

    7.4RequestHeader

    用的很少(获取请求头信息)

    image-20201120183847848

    @RequestMapping("/testRequestHeader")
    public String testRequestHeader(@RequestHeader(value = "Accept") String header){
       System.out.println(header);
       return "success";
    }
    <a href="testRequestHeader">RequestHeader</a>
    7.5CookieValue

    用的很少(获取Cookie信息)

    @RequestMapping("/testCookieValue")
    public String testCookieValue(@CookieValue(value = "JSESSIONID") String cookieValue){
       System.out.println(cookieValue);
       return "success";
    }
    <a href="testCookieValue">CookieValue</a>
    7.6ModelAttribute

    image-20201120194432089

    • 放在方法上,则是在调用controller之前执行这个方法(什么意思呢?就是只要你的这个请求走进了某个controller,那么这个controller下标注了@ModelAttribute注解的方法都会在调用前执行)

    //Person 中只有name与date两个字段
    @RequestMapping("/testModelAttribute")
    public String testModelAttribute(Person person){
        System.out.println("testModelAttribute执行");
        System.out.println(person);
        return "success";
    }
    
    @ModelAttribute
    public Person testMethod(String name){//name和传进来的是一样的
        System.out.println(name);
        Person person=new Person();
        person.setName("qwe");//原来有的不会覆盖,原来没有的则覆盖
        person.setDate(new Date());
        return person;
    }
    <form action="testModelAttribute" method="post">
        姓名:<input name="name"/><br/>
        <input type="submit" value="提交"/>
    </form>

    另一种无返回值的

    @RequestMapping("/testModelAttribute")
    public String testModelAttribute(Person person,@ModelAttribute(value = "abc") Person person1){
        System.out.println("testModelAttribute执行");
        System.out.println(person);//Person{name='宁新杰', date=null}
        System.out.println("==");
        System.out.println(person1);//Person{name='宁新杰', date=Fri Nov 20 20:15:32 CST 2020}
        return "success";
    }
    
    @ModelAttribute
    public void testMethod(String name, Map<String,Object> map){
        System.out.println("这里是AnnotationController");
        System.out.println(name);
        Person person=new Person();
        person.setName("qwe");//原来有的不会覆盖,原来没有的则覆盖
        person.setDate(new Date());
        map.put("abc",person);
    }

    7.7SessionAttribute

    这里有Model(就是存放到request中)

    (这个不要看这个注解了 , 学习中用到的是SessionAttributes,只能标注在类上)

    image-20201120204712192

    @RequestMapping("/testSeesionAttribute")
    public String testSeesionAttribute(Model model){
       System.out.println("testSeesionAttribute");
       //底层会存储到request域中
       model.addAttribute("msg","你好啊");
       //这样在success这个跳转页面使用${requestScope}取request所有信息能看到 或者直接使用${msg}获取值
       return "success";
    }

    image-20201120205025226

    image-20201120205212035

     

    什么叫Restful风格?

    请求地址都一样,根据不同的请求方式(如POST,GET,PUT,DELETE等)选择不同的方法执行

     

     

    8返回值为String的页面跳转

    //返回值类型为String
    @RequestMapping("/testString")
    public String testString(Model model){
       User user=new User("nxj","123",23);
       model.addAttribute("user",user);
       return "success";
    }
    <h1>this is success page</h1>
    <div style="color: aquamarine">
       <h1>testString</h1>
      ${user.toString()}
    </div>

    9无返回值的页面跳转实现

    //返回值类型为void
    @RequestMapping("/testVoid")
    public void testVoid( HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
       System.out.println("void method");
       //默认 按照视图解析器前缀/user/testVoid.jsp(.jsp就是后缀) 这个
       
       //方法一:使用转发(因为转发不走视图解析器,因此我们需要自己写完整的路径)(转发是在系统资源内,系统转发,因此可以跳转到任何系统内的资源页面)
       request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,response);
       
       //如果要到成功页面只能使用转发,若非WEB-INF下的页面则使用重定向
       
       //方法二:重定向,这是发的第二次请求,因此需要带上项目名(重定向不能走进WEB-INF下的页面)
       response.sendRedirect(request.getContextPath()+"/index.jsp");
       //为了防止转发后面有代码继续执行,加return
       return;
    }

    10forward转发于redirect重定向

    在强调一下:forward是系统内部资源转发,因此它能转发到WEB-INF下的资源,而redirect是外部重定向,因此重定向是无法直接访问WEB-INF下的资源

    使用关键字进行使用的时候不会经过视图解析器,因此我们需要写全

    @RequestMapping("/testForwardOrRedirect")
    public String testForwardOrRedirect(){
        System.out.println("testForwardOrRedirect");
        
        return "forward:/WEB-INF/pages/success.jsp";
        return "redirect:/user/testString"; //其中/user是class上requestMapping ;/testString是他下面的一个方法的requestMapping。
        return "redirect:/index.jsp";// 使用关键字的时候不需要加项目名称,因此框架底层帮我们做了,但是上面那代码直接调用就需要加。
    }

    ####

     

    11设置静态资源不拦截(js,css,图片等)

    <!--设置哪些静态资源不拦截(因为我们的前端控制器设置拦截/ 也就是所有的,因此这里我们需要设置哪些不需要拦截)-->
    <!--mapping映射的后面需要加** location不要加 我加了** 还是出不来-->
    <mvc:resources mapping="/js/**" location="/js/"/>

    image-20201121095933559

    12ModelAndView

    Model和View,也就是设置请求域值然后返回页面

    @RequestMapping("/testModelAndView")
    public ModelAndView testModelAndView(){
        ModelAndView modelAndView=new ModelAndView();
        User user=new User("nxj","132",23);
        //也会将对象存入到request域中
        modelAndView.addObject("user_mv",user);
        modelAndView.setViewName("success");//跳转到success页面(走视图解析器)
        return modelAndView;
    }

    13Ajax操作(@RequestBody,@ResponseBody)

    (我以后主要干的是后端,看这里的目的是用到了两个注解,一个是@RequestBody一个是@ResponseBody 一个是接受请求域中的消息体,一个是将消息体响应出去,现在知道他们的区别了吧!)

    (我们使用json来操作的,需要导入相应的jar包)

    整体是这样:ajax发送的时候url绑定到controller方法,ajax中data中的数据在controller下通过@RequestBody获取,ajax中的success的回调参数的数据,我们controller通过返回值前加@ResponseBody进行返回

    @RequestMapping("/testAjax")
    public @ResponseBody User testAjax(@RequestBody User user){
       System.out.println("...");
       System.out.println(user);
       User newUser=new User("xiaozhang","545",25);
       return newUser;
    }
    $(function(){
       $("#btn").click(function () {
           $.ajax({
               url:"user/testAjax",
               contentType:"application/json;charset=UTF-8",
               data :'{"username":"nxj","password":"456"}',
               dataType:"json",
               type:"post",
               success:function (data) {

              }
          });
      })
    });

    14.异常处理

    发生异常,我们向上抛,抛到了前端控制器,我们来处理,如果他不做处理则直接给浏览器,非常不好

    image-20201121110334648

    1. 编写自定义异常

    2. 编写异常处理器(需要实现HandlerExceptionResolver)

    3. 配置异常处理器

    //自定义异常
    public class MyException extends Exception {
    
        public MyException( String message) {
            this.message = message;
        }
    
        //存储异常提示信息
        private String message;
    
        @Override
        public String getMessage() {
            return message;
        }
    
        public void setMessage(String message) {
            this.message = message;
        }
    
    }
    //异常处理器类
    public class MyExceptionResolver implements HandlerExceptionResolver {
        @Override
        public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
            String message = ex.getMessage();
            MyException myEx=null;
            if(ex instanceof MyException){
                myEx=(MyException)ex;
            }
            else {
                myEx=new MyException("系统正在维护...");
            }
            ModelAndView modelAndView=new ModelAndView();
            modelAndView.setViewName("error");
            modelAndView.addObject("error_msg",myEx.getMessage());
            return modelAndView;
        }
    }
    <!--配置异常处理器(加入到组件中即可)-->
    <bean id="myExceptionResolver" class="com.jd.nxj.exceptions.MyExceptionResolver"/>

    15拦截器

    1. 编写拦截器类(需要实现HandlerInterceptor)

    2. 配置拦截器

    //自定义拦截器
    public class MyInterceptor1 implements HandlerInterceptor {
       //预处理(controller方法执行前,先走的它 )
       //return true 代表放行,走下一个拦截器(如果没有则直接执行controller中的方法)
       //return false 代表拦截,我们可以通过request,response 跳转到提示页面等
       @Override
       public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
           System.out.println("preHandle");
           //request.getRequestDispatcher("/WEB-INF/pages/warn.jsp").forward(request,response);
           return true;
      }
       //方法执行后走这个(页面加载前)
       @Override
       public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
           System.out.println("postHandle");
           request.getRequestDispatcher("/WEB-INF/pages/warn.jsp").forward(request,response);//我转发到这里,这样原来想跳转的就跳不过去,因为我先执行了
      }
       //页面加载后走这个
       @Override
       public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
           System.out.println("afterCompletion");
      }
    }
    <!--配置拦截器-->
    <mvc:interceptors>
       <mvc:interceptor>
           <!--要拦截的方法-->
           <mvc:mapping path="/my/*"/>
           <bean class="com.jd.nxj.interceptor.MyInterceptor1"/>
           <!--不要拦截的方法-->
           <!--<mvc:exclude-mapping path="com.jd.nxj.interceptor.MyInterceptor1"/>-->
       </mvc:interceptor>
    </mvc:interceptors>

     

    配置多个拦截器,他是链式走的,也就是先走1,再走2,方法执行完,回头走2,再走1,然后页面显示,然后页面加载完2,然后页面加载完1;这是放行的整个流程。

    //自定义拦截器
    public class MyInterceptor1 implements HandlerInterceptor {
       //预处理(controller方法执行前,先走的它 )
       //return true 代表放行,走下一个拦截器(如果没有则直接执行controller中的方法)
       //return false 代表拦截,我们可以通过request,response 跳转到提示页面等
       @Override
       public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
           System.out.println("preHandle11");
           //request.getRequestDispatcher("/WEB-INF/pages/warn.jsp").forward(request,response);
           return true;
      }
       //方法执行后走这个(页面加载前)
       @Override
       public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
           System.out.println("postHandle11");
           //request.getRequestDispatcher("/WEB-INF/pages/warn.jsp").forward(request,response);//我转发到这里,这样原来想跳转的就跳不过去,因为我先执行了
      }
       //页面加载后走这个
       @Override
       public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
           System.out.println("afterCompletion11");
      }
    }
    //自定义拦截器
    public class MyInterceptor2 implements HandlerInterceptor {
        //预处理(controller方法执行前,先走的它 )
        //return true 代表放行,走下一个拦截器(如果没有则直接执行controller中的方法)
        //return false 代表拦截,我们可以通过request,response 跳转到提示页面等
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            System.out.println("preHandle222");
            //request.getRequestDispatcher("/WEB-INF/pages/warn.jsp").forward(request,response);
            return true;
        }
        //方法执行后走这个(页面加载前)
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
            System.out.println("postHandle222");
            //request.getRequestDispatcher("/WEB-INF/pages/warn.jsp").forward(request,response);//我转发到这里,这样原来想跳转的就跳不过去,因为我先执行了
        }
        //页面加载后走这个
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            System.out.println("afterCompletion222");
        }
    }
    <!--配置拦截器-->
    <mvc:interceptors>
        
        <!--第一个拦截器-->
        <mvc:interceptor>
            <!--要拦截的方法-->
            <mvc:mapping path="/my/*"/>
            <bean class="com.jd.nxj.interceptor.MyInterceptor1"/>
            <!--不要拦截的方法-->
            <!--<mvc:exclude-mapping path="com.jd.nxj.interceptor.MyInterceptor1"/>-->
        </mvc:interceptor>
    
        <!--第二个拦截器-->
        <mvc:interceptor>
            <!--要拦截的方法-->
            <mvc:mapping path="/my/*"/>
            <bean class="com.jd.nxj.interceptor.MyInterceptor2"/>
            <!--不要拦截的方法-->
            <!--<mvc:exclude-mapping path="com.jd.nxj.interceptor.MyInterceptor1"/>-->
        </mvc:interceptor>
    </mvc:interceptors>
    @RequestMapping("/test")
    public String test(){
        System.out.println("test");
        return "success";
    }
    #结果
    preHandle11
    preHandle222
    test
    postHandle222
    postHandle11
    hello page execute method
    afterCompletion222
    afterCompletion11

     

    SpringMVC.xml

    不太全

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
          xmlns:mvc="http://www.springframework.org/schema/mvc"
          xmlns:context="http://www.springframework.org/schema/context"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/mvc
           http://www.springframework.org/schema/mvc/spring-mvc.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd">
       <!--开启注解扫描-->
       <context:component-scan base-package="com.jd.nxj"/>
       <!--视图解析器-->
       <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
           <property name="prefix" value="/WEB-INF/pages/"/>
           <property name="suffix" value=".jsp"/>
       </bean>
       <!--开启MVC注解支持-->
       <mvc:annotation-driven  conversion-service="conversionServiceFactoryBean"/>

       <!--类型转换器-->
       <bean id="conversionServiceFactoryBean" class="org.springframework.context.support.ConversionServiceFactoryBean">
           <property name="converters" ref="string2DateConverter"/>
       </bean>
       <bean id="string2DateConverter" class="com.jd.nxj.utils.String2DateConverter"/>

       <!--设置哪些静态资源不拦截(因为我们的前端控制器设置拦截/ 也就是所有的,因此这里我们需要设置哪些不需要拦截)-->
       <!--mapping映射的后面需要加** location不要加 我加了** 还是出不来-->
       <mvc:resources mapping="/js/**" location="/js/"/>

       <!--配置异常处理器-->
       <bean id="myExceptionResolver" class="com.jd.nxj.exceptions.MyExceptionResolver"/>
    </beans>

    web.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app version="2.4"
            xmlns="http://java.sun.com/xml/ns/j2ee"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

     <!--前端控制器-->
     <servlet>
       <servlet-name>dispatcherServlet</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <!--加载配置文件-->
       <init-param>
         <param-name>contextConfigLocation</param-name>
         <param-value>classpath:springmvc.xml</param-value>
       </init-param>
       <!--启动的时候就创建servlet,由此DispatcherServlet就被创建,classpath:springmvc.xml的配置文件也就被引入进来,
       那么这个xml下的配置,比如bean,以及他扫描包下添加进组件的,都会被添加进ioc容器-->
       <load-on-startup>1</load-on-startup>
     </servlet>

     <servlet-mapping>
       <servlet-name>dispatcherServlet</servlet-name>
       <!--这里不能写/* 要不然404找不到主页面-->
       <url-pattern>/</url-pattern>
     </servlet-mapping>


     <!--配置过滤器-->
     <filter>
       <filter-name>characterEncodingFilter</filter-name>
       <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
       <init-param>
         <param-name>encoding</param-name>
         <param-value>UTF-8</param-value>
       </init-param>
     </filter>

     <filter-mapping>
       <filter-name>characterEncodingFilter</filter-name>
       <!--这个必须/*-->
       <url-pattern>/*</url-pattern>
     </filter-mapping>

    </web-app>
           

     

    SSM需要的pom文件

    <dependencies>
      <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
      <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.6</version>
        <scope>runtime</scope>
      </dependency>
    
      <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.2.10.RELEASE</version>
      </dependency>
    
      <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.10.RELEASE</version>
      </dependency>
    
      <!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>5.2.10.RELEASE</version>
      </dependency>
    
      <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.10.RELEASE</version>
      </dependency>
    
      <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.2.10.RELEASE</version>
        <scope>test</scope>
      </dependency>
    
      <!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
      <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.2.10.RELEASE</version>
      </dependency>
    
      <!-- https://mvnrepository.com/artifact/junit/junit -->
      <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
      </dependency>
    
      <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
      <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
      </dependency>
    
      <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
      <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
      </dependency>
    
      <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/jsp-api -->
      <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.2</version>
        <scope>provided</scope>
      </dependency>
    
      <!--日志-->
      <!-- https://mvnrepository.com/artifact/log4j/log4j -->
      <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
      </dependency>
    
      <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
      <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.30</version>
      </dependency>
    
      <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
      <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.25</version>
        <scope>test</scope>
      </dependency>
    
      <!--mybatis-->
      <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
      <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.2</version>
      </dependency>
    
      <!-- https://mvnrepository.com/artifact/c3p0/c3p0 -->
      <dependency>
        <groupId>c3p0</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.1.2</version>
      </dependency>
    
      <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
      <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
      </dependency>
    
    </dependencies>

    Spring整合SpringMVC

    Spring-web中提供了这个监听器:ContextLoaderListener

    监听器默认只加载WEB-INF下的applicationContex.xml

    <!--配置Spring的监听器,默认只加载WEB-INF目录下的applicationContext.xml配置文件-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!--设置配置文件的目录-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

     

    以下是mapper.xml 自己看看记一下这块

    <resultMap type="com.jd.b2b.central.control.entity.Category" id="CategoryMap">
       <result property="id" column="id" jdbcType="INTEGER"/>
       <result property="extendId" column="extend_id" jdbcType="INTEGER"/>
       <result property="firstClass" column="first_class" jdbcType="INTEGER"/>
       <result property="firstClassName" column="first_class_name" jdbcType="VARCHAR"/>
       <result property="secondClass" column="second_class" jdbcType="INTEGER"/>
       <result property="secondClassName" column="second_class_name" jdbcType="VARCHAR"/>
       <result property="createUser" column="create_user" jdbcType="VARCHAR"/>
       <result property="updateUser" column="update_user" jdbcType="VARCHAR"/>
       <result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
       <result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
       <result property="yn" column="yn" jdbcType="TINYINT"/>
       <result property="ts" column="ts" jdbcType="TIMESTAMP"/>
    </resultMap>

    <!--查询单个-->
    <select id="queryById" resultMap="CategoryMap">
      select
        id, extend_id, first_class, first_class_name, second_class, second_class_name, create_user, update_user, create_time, update_time, yn, ts
      from category
      where id = #{id}
    </select>

     

    Spring整合Mybatis

    spring如何整合mybatis呢?想想看,我们mybatis需要调用SqlSessionFactory生成SqlSession,通过SqlSession调用数据库,那么我们如果将SqlSession放到Spring的容器中,岂不是就可以注入了,就是这个思想!

     

    <dependencies>
       <!-- spring -->
       <dependency>
           <groupId>org.aspectj</groupId>
           <artifactId>aspectjweaver</artifactId>
           <version>1.6.8</version>
       </dependency>

       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-aop</artifactId>
           <version>${spring.version}</version>
       </dependency>

       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-context</artifactId>
           <version>${spring.version}</version>
       </dependency>

       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-web</artifactId>
           <version>${spring.version}</version>
       </dependency>

       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-webmvc</artifactId>
           <version>${spring.version}</version>
       </dependency>

       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-test</artifactId>
           <version>${spring.version}</version>
       </dependency>

       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-tx</artifactId>
           <version>${spring.version}</version>
       </dependency>

       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-jdbc</artifactId>
           <version>${spring.version}</version>
       </dependency>

       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.12</version>
           <scope>compile</scope>
       </dependency>

       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>${mysql.version}</version>
       </dependency>

       <dependency>
           <groupId>javax.servlet</groupId>
           <artifactId>servlet-api</artifactId>
           <version>2.5</version>
           <scope>provided</scope>
       </dependency>

       <dependency>
           <groupId>javax.servlet.jsp</groupId>
           <artifactId>jsp-api</artifactId>
           <version>2.0</version>
           <scope>provided</scope>
       </dependency>

       <dependency>
           <groupId>jstl</groupId>
           <artifactId>jstl</artifactId>
           <version>1.2</version>
       </dependency>

       <!-- log start -->
       <dependency>
           <groupId>log4j</groupId>
           <artifactId>log4j</artifactId>
           <version>${log4j.version}</version>
       </dependency>

       <dependency>
           <groupId>org.slf4j</groupId>
           <artifactId>slf4j-api</artifactId>
           <version>${slf4j.version}</version>
       </dependency>

       <dependency>
           <groupId>org.slf4j</groupId>
           <artifactId>slf4j-log4j12</artifactId>
           <version>${slf4j.version}</version>
       </dependency>

       <!-- log end -->
       <dependency>
           <groupId>org.mybatis</groupId>
           <artifactId>mybatis</artifactId>
           <version>${mybatis.version}</version>
       </dependency>

       <dependency>
           <groupId>org.mybatis</groupId>
           <artifactId>mybatis-spring</artifactId>
           <version>1.3.0</version>
       </dependency>

       <dependency>
           <groupId>c3p0</groupId>
           <artifactId>c3p0</artifactId>
           <version>0.9.1.2</version>
           <type>jar</type>
           <scope>compile</scope>
       </dependency>
    </dependencies>

     

  • 相关阅读:
    switch语句相关
    大根堆的创建过程
    总结Java中线程的状态及多线程的实现方式
    用直接路径(direct-path)insert提升性能的两种方法
    Oracle的日志记录模式
    针对WebLogic Server 12.1.3版本打补丁
    Oracle Service Bus中的线程
    简化调用Web Service
    网络知识收集
    WebLogic MBean Monitor
  • 原文地址:https://www.cnblogs.com/ningxinjie/p/14014618.html
Copyright © 2011-2022 走看看