springboot+mybatis+freemarker的简单模板搭建

这里使用maven-web 模板搭建spring+mybatis+freemarker模板,但一般使用quick-start来搭建.因为spring是用于服务,不建议与jsp使用.
本篇文章偏重于视图层资源的访问获取和一些坑点的解决。
例如@RestController和@Controlle的区别，freemarker访问templates下的资源和访问webapp下的资源j，jsp访问webapp下的资源。
项目结构

一些依赖的导入，具体看注释
pom.xml

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

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ldg</groupId>
    <artifactId>springboot_02</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>springboot_02</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>
    <!--父工程-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <!-- SpringBoot 核心组件 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--访问jsp时需要的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>


        <!-- JDBC -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>


        <!-- 数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>


        <!-- mybaties -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>


        <!--使用druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.25</version>
        </dependency>

        <!--使用springboot+jta+atomikos 分布式事物管理解决方案-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jta-atomikos</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--解决Spring Boot Configuration Annotation Proessor not found in classpath-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>
        <!--去除springboot的logging，因为自带的logging不启效果-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--添加必要的spring日志包-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <!--添加log4j日志包-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.9</version>
        </dependency>
        <!-- 导入AOP依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!-- 引入freeMarker的依赖包. -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
    </dependencies>

    <build>
        <finalName>springboot_02</finalName>

        <plugins>

            <!--解决包远行时找不到主清单属性问题 ：设置好主加载类-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>

        </plugins>

        <!--扫描java下的所有.xml文件-->
        <resources>
            <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.xml</include>
            </includes>
        </resource>
         <!--扫描resources下的所有文件 这样导包时才会将那些配置文件放入包中-->
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.*</include>
                </includes>
            </resource>
        </resources>
    </build>
</project>

log4j使用时的一些必须配置
log4j.properties

og4j.rootLogger=INFO,Console,File
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.Target=System.out
log4j.appender.Console.layout = org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c - %L]%m%n

log4j.appender.File = org.apache.log4j.RollingFileAppender
#日志文件存放位置
log4j.appender.File.File =C:/Users/Administrator/Desktop/test/logs/info/info.log
#每个日志文件的大小不能超过10mb
log4j.appender.File.MaxFileSize = 10MB
log4j.appender.File.Threshold = ALL
log4j.appender.File.layout = org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c - %L]%m%n

一些全局配置信息
application.properties

server.port=10002
#在webapp下放页面资源(.jsp)时需要配置这个
#spring.mvc.view.prefix=/WEB-INF/view/
#spring.mvc.view.suffix=.jsp

#在webapp下放页面资源(.ftl)时需要配置这个
#默认情况下以下的属性的值是这些
#spring.freemarker.suffix=.ftl
#spring.freemarker.templateEncoding=UTF-8
#spring.freemarker.templateLoaderPath=classpath:/templates/
#spring.freemarker.content-type=text/html

spring.freemarker.templateEncoding=UTF-8
spring.freemarker.suffix=.ftl
spring.freemarker.content-type=text/html
spring.freemarker.template-loader-path=/WEB-INF/view/


#声明freemarker的request域对象
spring.freemarker.request-context-attribute=request
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource  
spring.datasource.url = jdbc:mysql:///springboot?useUnicode=true&characterEncoding=utf-8
spring.datasource.username = ldg
spring.datasource.password = 714838871
spring.datasource.driverClassName = com.mysql.jdbc.Driver

#连接池的配置信息
spring.datasource.initialSize=5
spring.datasource.minIdle=5
spring.datasource.maxActive=20
spring.datasource.maxWait=60000
spring.datasource.timeBetweenEvictionRunsMillis=60000
spring.datasource.minEvictableIdleTimeMillis=300000
spring.datasource.validationQuery=SELECT 1 FROM DUAL
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
spring.datasource.poolPreparedStatements=true
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
spring.datasource.filters=stat,wall,log4j
spring.datasource.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

日志切面类：获取controller下的所有方法的请求信息和响应信息
WebLogAspect.java

package com.ldg.aop;

import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

import java.util.Enumeration;

import javax.servlet.http.HttpServletRequest;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
//切面类
@Aspect
@Component
public class WebLogAspect {
    private Logger logger = Logger.getLogger(getClass());

    //声明切入点是controller下所有的方法
    @Pointcut("execution(public * com.ldg.web.controller..*.*(..))")
    public void webLog() {

    }

    //weblog方法前要做的事
    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        //HttpServletRequest接口继承ServletRequest
        //转换成httpservletrequest请求
        HttpServletRequest request = attributes.getRequest();
        // 记录下请求内容
        logger.info("---------------request----------------");
        logger.info("URL : " + request.getRequestURL().toString());
        logger.info("HTTP_METHOD : " + request.getMethod());
        logger.info("IP : " + request.getRemoteAddr());
        //将请求中的参数名封装起来
        Enumeration<String> enu = request.getParameterNames();
        while (enu.hasMoreElements()) {
            String name = (String) enu.nextElement();
            logger.info("name:" + name + "  value:" + request.getParameter(name));
    }
    }

    //weblog方法后要做到事
    @AfterReturning(returning = "ret", pointcut = "webLog()")
    public void doAfterReturning(Object ret) throws Throwable {
        logger.info("---------------response----------------");
        // 处理完请求，返回内容
        logger.info("RESPONSE : " + ret);
    }
}

从全局配置中获取druid连接池一些配置信息并配置数据源
DruidDBConfig.java

package com.ldg.dbconfig;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;
import java.sql.SQLException;

//获取druid连接池一些配置信息并配置数据源
@Configuration
public class DruidDBConfig {
    private Logger logger = Logger.getLogger(DruidDBConfig.class);

    @Value("${spring.datasource.url}")
    private String dbUrl;

    @Value("${spring.datasource.username}")
    private String username;

    @Value("${spring.datasource.password}")
    private String password;

    @Value("${spring.datasource.driverClassName}")
    private String driverClassName;

    @Value("${spring.datasource.initialSize}")
    private int initialSize;

    @Value("${spring.datasource.minIdle}")
    private int minIdle;

    @Value("${spring.datasource.maxActive}")
    private int maxActive;

    @Value("${spring.datasource.maxWait}")
    private int maxWait;

    @Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
    private int timeBetweenEvictionRunsMillis;

    @Value("${spring.datasource.minEvictableIdleTimeMillis}")
    private int minEvictableIdleTimeMillis;

    @Value("${spring.datasource.validationQuery}")
    private String validationQuery;

    @Value("${spring.datasource.testWhileIdle}")
    private boolean testWhileIdle;

    @Value("${spring.datasource.testOnBorrow}")
    private boolean testOnBorrow;

    @Value("${spring.datasource.testOnReturn}")
    private boolean testOnReturn;

    @Value("${spring.datasource.poolPreparedStatements}")
    private boolean poolPreparedStatements;

    @Value("${spring.datasource.maxPoolPreparedStatementPerConnectionSize}")
    private int maxPoolPreparedStatementPerConnectionSize;

    @Value("${spring.datasource.filters}")
    private String filters;

    @Value("{spring.datasource.connectionProperties}")
    private String connectionProperties;

    @Bean     //声明其为Bean实例
    @Primary  //在同样的DataSource中，首先使用被标注的DataSource
    public DataSource dataSource() {
        DruidDataSource datasource = new DruidDataSource();

        datasource.setUrl(this.dbUrl);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);

        //configuration
        datasource.setInitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);
        datasource.setMaxWait(maxWait);
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setValidationQuery(validationQuery);
        datasource.setTestWhileIdle(testWhileIdle);
        datasource.setTestOnBorrow(testOnBorrow);
        datasource.setTestOnReturn(testOnReturn);
        datasource.setPoolPreparedStatements(poolPreparedStatements);
        datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        try {
            datasource.setFilters(filters);
        } catch (SQLException e) {
            logger.error("druid configuration initialization filter", e);
        }
        datasource.setConnectionProperties(connectionProperties);

        return datasource;
    }
}

接口声明
IUserMapper.java

package com.ldg.mapper;

import com.ldg.model.User;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

public interface IUserMapper {
    //注解配置
    //会自动与注解生成代理
//    @Insert("insert  test  values(#{username},#{password})")
//    public void save(@Param("username") String username, @Param("password") String password);
//
//    @Select("select *  from  test  where username=#{a}")
//    public User foundUser(@Param("a") String username);

    public void save(String username, String password);

    public User foundUser(String username);
}

IUserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.ldg.mapper.IUserMapper" >
    <insert id="save">
        insert into test (username,password) VALUES(#{0},#{1})
    </insert>
    <select id="foundUser" resultType="com.ldg.model.User" parameterType="string">
        select * from test where username = #{username}
    </select>
</mapper>

** 扫描注解扫描包是默认接口和mapper.xml名称一致**

UserController

package com.ldg.web.controller;

import com.ldg.model.User;
import com.ldg.service.IUserService;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;


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

import org.springframework.web.bind.annotation.ResponseBody;


@Controller
@RequestMapping("/test")
public class UserController {
    @Autowired
    @Qualifier("test01")
    private IUserService iUserService;

    @RequestMapping("/list")

    public String test() {

        return "one";


    }

    // Logger logger = Logger.getLogger(IUserService.class);

    @RequestMapping("/save/{username}/{password}")
    @ResponseBody
    public String save(@PathVariable String username, @PathVariable String password) {
        //logger.info("username:"+username+" password:"+password);
        iUserService.save(username, password);
        return "success";
    }

    @RequestMapping("/get/{username}")
    @ResponseBody
    public User get(@PathVariable String username) {
        return iUserService.foundUser(username);
    }

    //会自动将url中的值封装到方法参数中
    @RequestMapping("/savetwo")
    public String saveTwo(String username, String password) {
        //logger.info("username:"+username+" password:"+password);
        iUserService.save(username, password);
        return "success";
    }
}

控制器这注意@Controller和@RestController的区别
1）@Controller类中的方法可以直接通过返回String跳转到jsp、ftl、html等模版页面。在方法上加 @ResponseBody注解，也可以返回实体对象。

2）@RestController类中的所有方法只能返回String、Object、Json等实体对象，不能跳转到模版页面。

3）@RestController相当于@ResponseBody + @Controller。

springboot web静态资源的访问
在我们开发Web应用的时候，需要引用大量的js、css、图片等静态资源。
Spring Boot默认提供静态资源目录位置需置于classpath下，目录名需符合如下规则：
/static
/public
/resources
/META-INF/resources
举例：我们可以在src/main/resources/目录下创建static，在该位置放置一个图片文件。启动程序后，尝试访问http://localhost:8080/imgs/d.jpg。如能显示图片，配置成功。

使用jsp访问webapp下的资源时需要在application.properties下加入以下配置
Spring Boot建议使用这些模板引擎，避免使用JSP，若一定要使用JSP将无法实现Spring Boot的多种特性，

#在webapp下放页面资源(.jsp)时需要配置这个
spring.mvc.view.prefix=/WEB-INF/view/
spring.mvc.view.suffix=.jsp

使用freemarker访问webapp下的资源时需要在application.properties下加入以下配置

#在webapp下放页面资源(.ftl)时需要配置这个
#默认情况下以下的属性的值是这些
#spring.freemarker.suffix=.ftl
#spring.freemarker.templateEncoding=UTF-8
#spring.freemarker.templateLoaderPath=classpath:/templates/
# spring.freemarker.prefix=
#spring.freemarker.content-type=text/html
spring.freemarker.template-loader-path=/WEB-INF/view/

默认情况下有些属性是有值的，只需要改变spring.freemarker.template-loader-path的值

关于spring.freemarker.template-loader-path和spring.freemarker.prefix的区别和使用
原码没看不知道具体原因
spring.freemarker.template-loader-path的优先级别要高于spring.freemarker.prefix 只需要更改spring.freemarker.template-loader-path的值就能改变资源访问路径的前缀.

以上是主要代码 都能跑通