springboot学习之搭建ssm

一、运行环境

　　1. mysql 5.7   64位

　　2. jdk 1.8   64位

　　3.ecplice 4.5  64位

二、创建一个springboot项目

　　1. 在ecplice中创建一个maven的webapp项目

　　　　　　点击左上角菜单栏中的File -------》New -------》Maven Project

　　　　　　

　　2. 一直点击继续直到如下页面（选中webapp类型的项目进行创建，选好了继续点击next）

　　　　　　

 　　3. 输入你的组名和项目名，输入后点击Finish完成创建即可。

　　　　　　

 　　4. 完成后你的项目目录如下：

　　　　　　

 　　5. 点击你的pom.xml文件，将需要的jar包添加进去

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.test</groupId>
  <artifactId>SpringbootProject</artifactId>
  <packaging>war</packaging>
  <version>0.0.1-SNAPSHOT</version>
  <name>Springboot1029 Maven Webapp</name>
  <url>http://maven.apache.org</url>
  
  <!-- 定义公共资源版本，Springboot的父级依赖，这样当前的项目就是Springboot项目了，它提供相关的Maven默认依赖，使用它之后，常用的包依赖可以省略version标签 -->
  <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
  </properties>
  
  <dependencies>
      <!-- 由于上面引入了父级依赖，所以下面我就不需要指定版本了，包含aop jdbc web等jar资源 -->
    <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 导入mysql的驱动包依赖 -->
    <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
    </dependency>
    <!-- 单元测试的依赖包 -->
    <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
    </dependency>

    <!--mybatis的依赖包-->
    <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
    </dependency>
        
    <!-- servlet依赖. -->  
    <dependency>  
            <groupId>javax.servlet</groupId>  
            <artifactId>javax.servlet-api</artifactId>  
            <scope>provided</scope>  
    </dependency>  
           
    <!-- 导入jsp相关依赖，需要注意的是，如果我们不添加这个依赖包，会造成返回的controller的返回的jsp页面出现404错误 -->
    <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <scope>provided</scope>
    </dependency>
    <!-- JSTL（JSP Standard TagLibrary，JSP标准标签库)是一个不断完善的开放源代码的JSP标签库，是由apache的jakarta小组来维护的。JSTL只能运行在支持JSP1.2和Servlet2.3规范的容器上，如tomcat   
            4.x。在JSP2.0中也是作为标准支持的。 不然报异常信息： javax.servlet.ServletException:Circular view   
            path [/helloJsp]: would dispatch back to the current handler URL[/helloJsp]   
            again. Check your ViewResolver setup! (Hint: This may be the resultof an   
            unspecified view, due to default view name generation.) --> 
    <dependency>  
            <groupId>javax.servlet</groupId>  
            <artifactId>jstl</artifactId>  
    </dependency> 
  </dependencies>
  <build>
    <finalName>SpringbootProject</finalName>
    <!-- Spring Boot Maven plugin是springboot的一款插件，能够将Spring Boot应用打包为可执行的jar或war文件 -->
    <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
   </plugins>
   <!--配置Maven 对resource文件 过滤 -->
   <resources>
             <resource>
                 <directory>src/main/resources</directory>
                 <includes>
                     <include>**/*.properties</include>
                     <include>**/*.xml</include>
                 </includes>
                 <filtering>true</filtering>
             </resource>
             <resource>
                 <directory>src/main/java</directory>
                 <includes>
                     <include>**/*.properties</include>
                     <include>**/*.xml</include>
                 </includes>
                 <filtering>true</filtering>
             </resource>
    </resources>
  </build>
</project>

　　6. springboot只有一个配置文件application.properties

　　　　　　位于 src/main/resources :

　　　　　　　　

 　　　　　 文件application.properties的内容为：

# 设置tomcat访问的端口号
server.port=8080
# 设置tomcat访问该项目的名称，如果不写，默认无项目名称，该项目名称可以与创建项目的名称不一样，访问时根据这个设置的项目名称来进行访问
# 如下我配置后访问的地址为：http://localhost:8080/SpringbootSSM/ + controller的映射地址
# 如果我们不配置应该访问的地址是： http://localhost:8080/ + controller中的映射地址
# 和我创建项目时使用的名称SpringbootProject无任何直接关系
server.context-path=/SpringbootSSM

# 配置日志显示的等级
logging.level.org.springframework=DEBUG
#springboot   mybatis
#加载 mybatis配置文件
mybatis.mapper-locations = classpath:com/test/mapper/*Mapper.xml
mybatis.type-aliases-package = com.test.pojo

#配置数据库连接信息
spring.datasource.driver-class-name= com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/xiaoxiao?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.username = xiaoxiao
spring.datasource.password = xiaoxiao

# jsp页面默认前缀目录
spring.mvc.view.prefix=/WEB-INF/content/
# jsp响应页面默认后缀
spring.mvc.view.suffix=.jsp

　　7. 创建项目启动类 （在 src/main/java 下的 com/test 目录下）：

　　　　　　需要注意的是：刚创建好的项目目录下的main下可能没有java这个文件夹，你可以自己创建出来，然后在java的文件夹下创建文件夹用来存放你的项目中的具体内容，这里我创建的com.test两层文件夹，然后在该文件夹下创建对应的存放具体内容的文件夹：例如： 1. controller文件夹用来存放controller文件，2. mapper文件夹用来存放我们的数据库接口和数据库的xml文件，3. pojo文件夹用来存放我们的数据库中表对应的实体类，4. service文件夹用来存放我们的服务层接口和服务层实现类文件，5. until文件夹用来存放我们自己编写的工具类或者静态变量文件

　　　　　　位置如下图：

　　　　　　　　

 　　　　　　SpringbootEnter的文件内容为：

package com.test;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.transaction.annotation.EnableTransactionManagement;

# @SpringBootApplication注解用来开始springboot的扫描
# @EnableTransactionManagement 用来启动事务管理
@SpringBootApplication  
@EnableTransactionManagement
public class SpringbootEnter{
        
    public static void main(String[] args){
        SpringApplication.run(SpringbootEnter.class, args);
    }
}

　　　　　　这时，我们的springboot项目就配置好了，需要注意的是：springboot是通过右键SpringbootEnter.java选择 run_as 中的 Java Application来进行启动项目的，它不需要加入到tomcat的服务器中去，它有自己的内置服务器。

　　　　　　接下来我们建立一个数据库连接测试，查看我们的springboot配置是否成功配置。

　　8. 在数据库中创建表，并在项目中创建对应的实体类

　　　　　　数据库中创建表：

mysql   -uxiaoxiao -pxiaoxiao           # 登录mysql数据库
use    xiaoxiao                         # 使用xiaoxiao数据库
CREATE TABLE food (
  id int(11) primary key,
  f_name varchar(20) ,
  f_price float,
  f_come float
) ENGINE=InnoDB DEFAULT CHARSET=gbk;    # 创建表
INSERT INTO food VALUES (1,'苹果',11.8,3.2),(2,'橘子',12.7,5.2),(3,'香蕉',18.2,8.2);                  # 向表中插入数据

　　　　　　项目中创建对应的实体类（位置：src/mian/java/ 下的  com/test/ 下的 pojo/ 下的Food.java文件为该表的实体类）：

　　　　　　　　　　

 　　　　　　　Food.java的文件内容为：　　　

package com.test.pojo;

/**
 * 功能： 数据库xiaoxiao中的Food表的实体类
 * @param 
 *         id   食物编号
 *        f_name  食物名称
 *        f_price 食物价格
 *        f_come  食物进价
 */
public class Food {

    private int id;         
    private String f_name;  
    private float f_price;  
    private float f_come;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getF_name() {
        return f_name;
    }
    public void setF_name(String f_name) {
        this.f_name = f_name;
    }
    public float getF_price() {
        return f_price;
    }
    public void setF_price(float f_price) {
        this.f_price = f_price;
    }
    public float getF_come() {
        return f_come;
    }
    public void setF_come(float f_come) {
        this.f_come = f_come;
    }
    @Override
    public String toString() {
        return "Food [id=" + id + ", f_name=" + f_name + ", f_price=" + f_price + ", f_come=" + f_come + "]";
    }
    
}

　　9. 创建数据库接口，数据库xml文件（位置在： src/main/java  下的 com/test/mapper 目录下）

 　　　　　　

#  TestMapper.java
package com.test.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Mapper;

import com.test.pojo.Food;

@Mapper
public interface TestMapper {
    
    /**
     * 功能：查询全部食物信息
     * @return
     */
    public List<Food> selectFood();

}

#  TestMapper.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中的命名空间，一定要写TestMapper.java的位置 -->
<mapper namespace="com.test.mapper.TestMapper">

　　 <!-- 查询全部食物信息 -->
    <select id="selectFood" resultType="com.test.pojo.Food">
        select * from food
    </select>

</mapper>

　　10. 创建服务接口和实现类（位置在： src/main/java  下的 com/test/service 目录下）

　　　　　　

#   TestService.java
package com.test.service;

import java.util.List;

import com.test.pojo.Food;

public interface TestService {
    
    /**
     * 功能：查询全部食物信息
     * @return
     */
    public List<Food> selectFood();
}

#  TestServiceImpl .java
package com.test.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.test.mapper.TestMapper;
import com.test.pojo.Food;

@Service("testService")
public class TestServiceImpl implements TestService {

    @Autowired
    public TestMapper testMapper;
    
    /**
     * 功能：查询全部食物信息
     */
    @Override
    public List<Food> selectFood() {
        // TODO Auto-generated method stub
        return testMapper.selectFood();
    }

}

　　11. 创建controller类（位置在： src/main/java  下的 com/test/controller 目录下）

　　　　　　

#  TestController.java
package com.test.controller;

import java.util.List;

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.RequestMapping;

import com.test.pojo.Food;
import com.test.service.TestService;

@Controller
public class TestController {
    
    @Autowired
    @Qualifier("testService")
    public TestService testService;

    /**
     * 功能：测试页面
     * @return
     */
    @RequestMapping("test")
    public String test(){
        System.out.println("进入主页");
        List<Food> lf = testService.selectFood();
        System.out.println(lf);
        return "test";    
    }
    
}

　　12. 创建最后跳转的jsp页面（位置 src/main/webapp  下的 WEB-INF/content/test.jsp）

　　　　　　

# test.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
    我是jsp页面！
</body>
</html>

　　13. 最后右键启动类SpringbootEnter的启动成功效果如下：

　　　　　　

　　14. 启动成功后，可以访问  http://localhost:8080/SpringbootSSM/test 进行访问，访问成功后效果如下：

　　　　　　后台打印：

　　　　　　

　　　　　　前台页面：