SSM框架学习记录

SSM框架 Mybatis

认识mybatis：持久化 CRUD

最好将dao的接口和xml文件放到同一目录下

配置

导包

mysql-connector-java
mybatis
junit
log4j
spring-webmvc
配置resources，防止导出*.xml和*.properties失败的问题

    src/main/java
    
    
        ***.xml
    
    true


    src/main/resources
    
    
        ***.xml
    
    true

配置文件

日志，数据库配置文件

数据库配置文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mydatis?useSSL=true&useUnicode=true&charsetEncoding=UTF-8&serverTimezone=UTC
username=root
password=****

  

  
    
  
  - mybatis配置文件
  
    configuration
    1.properties 载入配置文件
    2.settings  设置日志类型，懒加载
    3.typeAliases 设置类型别名
    4.environments 配置成适应多种环境，有助于将 SQL 映射应用于多种数据库之中
    5.mappers 注册配置文件

ResultMap:结果集映射，一对多，多对一

多对一：association
select s.id sid,s.name sname,t.name tname from student s,teacher t where s.tid=t.id ```xml ```
一对多：colection
select t.id tid ,t.name tname ,s.id sid ,s.name sname from teacher t,student s where t.id = s.tid and t.id=#{id} ```xml ```

Log4j

配置

在mybatis里的configration里的setting标签里配置，默认是STDOUT_LOGGING

Log4j日志文件
#将等级为DEBUG的日志信息输出到console和file这两个目的地
log4j.rootLogger=DEBUG,console,file
#控制台输出相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern =[%c]-%m%n

#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/will.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern =[%p][%d{yy-MM-dd}][%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.sql.Result=DEBUG
log4j.logger.sql.PreparedStatement=DEBUG

分页注解开发

配置

将dao文件和对应dao.xml的配置文件放在同一文件夹下，在注册mapper时，利用class方式注册，
可使用以下注解
@Insert
@Update
@Delete
@Select

动态SQL

语法

if
choose (when, otherwise)
trim (where, set)
foreach




    
        
            title=#{title}
        
        
            and author=#{author}
        
    
    
        insert into blog (id,title,author,create_time,view)
        values(#{id},#{title},#{author},#{createTime},#{view})
    
    
        select * from blog
        
            
                
                    title=#{title}
                
                
                    and author=#{author}
                
                
                    and view=#{view}
                
            
        


    update blog
    
        
            title=#{title},
        
        
            author=#{author}
        
    
    
        id=#{id}

缓存

一级缓存：session
二级缓存：mapper

一个session结束后，将缓存放入mapper(单例模式，全程只有一个mapper)，则，下一个session可以访问该缓存。
映射语句文件中的所有 select 语句的结果将会被缓存。
映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
缓存不会定时进行刷新（也就是说，没有刷新间隔）。
缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

Spring

IOC理论推导

控制反转，将对象交给Bean管理

Spring 概述 IOC-Beans.xml

将对象注册为Bean

DI/Set 注入，c p 注入（重点）

字符串，数组，链表，map，空注入，以及c p注入

代理模式，静态代理，动态代理（重点）

将需要代理的target传入到代理对象，利用其实现接口的方法，并且可以添加额外的方法

package com.will.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyInvocationHandler implements InvocationHandler {

    private Object target;
    //获取代理对象
    public void setTarget(Object target) {
        this.target = target;
    }
    //生成动态代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }
    
    //处理动态代理的方法
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
        return method.invoke(target,args);
    }

}

//实现类
public class Host implements Rent {
    public void rent() {
        System.out.println("房东要租房了");
    }
}
//接口
public interface Rent {
    void rent();
}
//测试类
package com.will.proxy;

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(host);
        Rent proxy = (Rent) pih.getProxy();
        proxy.rent();

    }

}

AOP

使用原生API实现
```
    
    
    
    
    
```

使用自定义切面实现

使用注解实现



@Aspect

public class AnnoAOP {
    
    @Around("execution(* com.will.pojo.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        Signature signature = jp.getSignature();
        System.out.println("signature是"+signature);
        jp.proceed();
        System.out.println("环绕后");
    }
}

注解开发Spring

注解注册Bean

JavaConfig:半重点

@Configuration
@ComponentScan("com.will.pojo")
public class AppConfig {
    @Bean
    public User getUser(){
        return new User();
    }
}

代替配置文件

整合mybatis：事务（重点）

spring-mybatis.xml(配置数据源加声明式事务)

声明式事务

用于控制事务的提交，可以限制对数据库的增删改查，以及其他配置

Spring MVC

springmvc执行流程执行原理

请求->前端控制器->->前端映射器（映射匹配的contorller）和适配器（找到controller）->控制器
->service->dao->查询数据库
->选择要返回的视图并装入model携带返回->前端控制器->视图解析器->返回对应视图view给用户

spring-mvc.xml

结果跳转的方式

返回字符串（@RestMappering）
/返回视图(@RequestMappering)

forward(默认)
redirect

数据如何处理

Model
Session
Request
Response

乱码问题

利用Spring自带的message-converters可以解决

Controller

控制器：所有前端的请求都要请求控制器进行页面跳转，控制器中调用Service层实现处理业务逻辑，可以通过注解实现控制器

RestFull（重点）

是一种传递参数的风格，不是工具

前端请求
localhost:8080/login/will/123
@RequestMapping("/login/{name}/{password}")
请求用/{}，接收前端的参数，然后通过@PathVariable String name,
@PathVariable String password 来接收name=will和password=123

JSON

格式

{“key”：“value”,“key2”：“value2”}

使用

利用ObjectMapper对象的writevalueAsString(Object o)方法，可以将Object(数组，链表，Map等)转化为Json

工具类

package com.will.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;

public class JsonUtils {
    public static String getJson(Object o,String dataPattern) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false);
        SimpleDateFormat sdf = new SimpleDateFormat(dataPattern);
        mapper.setDateFormat(sdf);
        return mapper.writevalueAsString(o);
    }
    public static String getJson(Object o) throws JsonProcessingException {
        return getJson(o,"yyyy-MM-dd HH-mm-ss");
    }
}

Ajax&Jquery

导入静态资源
关系

1、JS是一门前端语言。
2、Ajax是一门技术，它提供了异步更新的机制，使用客户端与服务器间交换数据而非整个页面文档，实现页面的局部更新。
3、jQuery是一个框架，它对JS进行了封装，使其更方便使用。jQuery使得JS与Ajax的使用更方便
使用

用Jquery的封装的 . p o s t , .post, .post,.get等方法，可以使得Ajax的异步请求更加简洁，编写更方便。
```
$.post({
    url:"${pageContext.request.contextPath}/checkUser",
    data:{"username":$("#username").val()},
    success:function (data) {
        if (data.toString()==="ok"){
            $("#usermsg").css("color","green");
            $("#usermsg").html(data)
        } else {
            $("#usermsg").css("color", "red");
            $("#usermsg").html(data)
        }
    }
})
```

拦截器

定义

拦截器用于在某个方法或者字段被访问之前，进行拦截，然后再之前或者之后加入某些操作（事务，缓存，日志等）。

实现

自定义拦截器，实现HandlerInterceptor接口

package com.will.interceptor;

import org.springframework.web.servlet.HandlerInterceptor;

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

public class LoginInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HttpSession session = request.getSession();
        if (session.getAttribute("loginName")!=null){
            System.out.println("放行session");
            return true;
        }
        if (request.getRequestURI().contains("login")){
            System.out.println("放行login");
            return true;
        }
        System.out.println("拦截了，跳转到login");
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request,response);
        return false;
    }
}

配置文件中注册
```
    
        
        
    
```

与过滤器的区别

1，拦截器是基于java反射机制来实现的，而过滤器是基于函数回调来实现的。
2，拦截器不依赖servlet容器，过滤器依赖于servlet容器。
3，拦截器只对Action起作用，过滤器可以对所有请求起作用。
4，拦截器可以访问Action上下文和值栈中的对象，过滤器不能。
5，在Action的生命周期中，拦截器可以多次调用，而过滤器只能在容器初始化时调用一次。

整合SSM项目(重点)

SSM框架学习记录

Java相关栏目本月热门文章