首页 / MYSQL / SpringBoot实践 - SpringBoot+mysql

SpringBoot实践 - SpringBoot+mysql

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了SpringBoot实践 - SpringBoot+mysql，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含12166字，纯文字阅读大概需要18分钟。

内容图文

关于springBoot是个神马东西以及优缺点，请自行搜索了解。

LZ看到很多关于SpringBoot的Demo，单看一篇总是没法整合SpringBoot与Mysql。没法子，还是自己操刀来一发为妙。

本文将叙述关于SpringBoot与mysql整合实践。

1.Eclipse 整合SpringBoot插件。(此步骤非常耗时，LZ本身尝试了多次。请在网络环境优情况下下进行操作)

　　a.Eclipse 安装STS插件：

　　 eclipse->help->Eclipse Marketplace

技术分享

　　b.检测是否安装成功

　　　　安装成功后提示重启eclipse,重启后新建Project 出现如图

技术分享

 

2.新建SpringBoot Project

技术分享

-->next

技术分享

-->next (选择您需要的依赖，Finish后会在pom.xml中出现对应jar依赖) 

技术分享

-->Finish

项目结构如下：

技术分享 

            package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


            /*
            * 
* @ClassName: SpringBootDemoHelloApplication 
* @Description:
* SpringBootDemoHelloApplication.java 是SpringBoot应用程序入口，或者叫主程序。
* 注解@SpringBootApplication 标注他是一个SpringBoot应用，main方法使他成为一个主程序，将在应用启动时首先被执行。
* 注解@RestController 标注这也是一个控制器。
* @author mengfanzhu
* @date 2017年2月20日 下午6:36:42 

            */
            
@SpringBootApplication
@RestController

            public
            class
             SpringBootDemoHelloApplication {

    @RequestMapping(
            "
            /
            "
            )
    
            public
             String hello(){
        
            return
            "
            hello boot
            "
            ;
    }
    
    
            public
            static
            void
             main(String[] args) {
        SpringApplication.run(SpringBootDemoHelloApplication.
            class
            , args);
    }
}

 

　　3.启动SpringBoot应用

　　　　方式1:选择项目->右键

技术分享

　　方式2: eclipse->Windows->Show View

技术分享 技术分享

　　启动成功后：

技术分享

　　附加：

　　1.需要改动端口号：将resources下 application.properties 改为application.yml （个人爱好，可不改）

　　输入

            server:
  port: 
            9090
            
  tomcat:
    uri-encoding: UTF-8

　浏览器访问

技术分享

3.代码结构

技术分享 

4.代码示例

　　application.yml

            server:
  port: 
            9090
            
  tomcat:
    uri-encoding: UTF-8  
  
spring:
  datasource:
    url: jdbc:mysql://localhost:3307/test?characterEncoding=UTF-8    username: test1
    password: test1
    driver-class-name: com.mysql.jdbc.Driver
  jpa:
    database: MYSQL
    show-sql: true
    hibernate:
      ddl-auto: update
      naming-strategy: org.hibernate.cfg.ImprovedNamingStrategy
    properties:
      hibernate:
        dialect: org.hibernate.dialect.MySQL5Dialect

 

  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.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>spring_boot_demo_hello</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.1.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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>
                spring-boot-starter-data-elasticsearch
            </artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.sun.jna/jna -->
        <dependency>
            <groupId>com.sun.jna</groupId>
            <artifactId>jna</artifactId>
            <version>3.0.9</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-batch -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-batch</artifactId>
        </dependency>
        <!-- springboot 热部署 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional><!-- optional=true,依赖不会传递，该项目依赖devtools；之后依赖myboot项目的项目如果想要使用devtools，需要重新引入 -->
    </dependency>  
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

 

User.java

            package com.example.entity;

import java.io.Serializable;
import java.util.Date;
import java.util.List;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

import org.springframework.format.annotation.DateTimeFormat;

import com.fasterxml.jackson.annotation.JsonBackReference;


@Entity
@Table(name="boot_user")
publicclass User implements Serializable {
    
    /** 
    * @Fields serialVersionUID : TODO
    */privatestatic final long serialVersionUID = -6550777752269466791L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(length=50,nullable=false)
    private String name;
    
    private String loginName;
    
    private String password;
    
    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date createdate;
    
    @ManyToOne
    @JoinColumn(name = "did")
    @JsonBackReference
    private Department department;
    
    @ManyToMany(cascade={},fetch = FetchType.EAGER)
    @JoinTable(name = "user_role",
        joinColumns={@JoinColumn(name="user_id")},
        inverseJoinColumns = {@JoinColumn(name="roles_id")})
    private List<Role> roleList;

    public Long getId() {
        return id;
    }

    publicvoid setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    publicvoid setName(String name) {
        this.name = name;
    }

    public Date getCreatedate() {
        return createdate;
    }

    publicvoid setCreatedate(Date createdate) {
        this.createdate = createdate;
    }

    public String getLoginName() {
        return loginName;
    }

    publicvoid setLoginName(String loginName) {
        this.loginName = loginName;
    }

    public String getPassword() {
        return password;
    }

    publicvoid setPassword(String password) {
        this.password = password;
    }

    public Department getDepartment() {
        return department;
    }

    publicvoid setDepartment(Department department) {
        this.department = department;
    }

    public List<Role> getRoleList() {
        return roleList;
    }

    publicvoid setRoleList(List<Role> roleList) {
        this.roleList = roleList;
    }

    public User() {
        super();
        // TODO Auto-generated constructor stub    }

    public User(Long id, String name, String loginName, String password,
            Date createdate, Department department, List<Role> roleList) {
        super();
        this.id = id;
        this.name = name;
        this.loginName = loginName;
        this.password = password;
        this.createdate = createdate;
        this.department = department;
        this.roleList = roleList;
    }

    
}

 

Department.java,Role.java 代码参照User.java代码即可

UserDao.java

            package com.example.dao;

import java.util.Date;
import java.util.List;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import com.example.entity.User;
@Repository

            public
            interface UserDao extends JpaRepository<User, Long> {
    
    User findByLoginNameLike(String name);

    User readByLoginName(String name);

    List<User> getByCreatedateLessThan(Date star);
}

 

DepartmentDao.java，RoleDao.java参考UserDao.java 即可，这样就实现了分页、增删改查等功能。很便捷有木有！那为什么呢？看下JpaRepository接口，方法命名规则及相关问题后续重点介绍.

 

UserController.java

            package com.example.controller;

import java.util.HashMap;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import com.example.entity.User;
import com.example.service.DataService;
import com.example.service.UserService;


            /*
            * 
* @ClassName: UserController 
* @Description: User控制器
* @author mengfanzhu
* @date 2017年2月20日 下午5:58:19 

            */
            
@RestController
@RequestMapping(
            "
            /user
            "
            )

            public
            class
             UserController {
    
    
            protected
            static Logger logger=LoggerFactory.getLogger(UserController.class);  
    @Autowired
    private UserService userService;
    @Autowired
    private DataService dataService;
    
    @RequestMapping("/demo/{name}")
    @ResponseBody
    public String demoShowName(@PathVariable String name){
         logger.debug("访问getUserByName,Name={}",name);  
         return"name is " + name;
    }
    /** 
     * @Title: UserController
     * @Description: 数据初始化
     * @author mengfanzhu
     * @throws 
     */
    @RequestMapping("/initdata")
    @ResponseBody
    public String initData(){
        dataService.initData();
        return"success";
    }
    
    /** 
     * @Title: UserController
     * @Description: 由loginName获取user
     * @param loginName
     * @author mengfanzhu
     * @throws 
     */
    @RequestMapping("/getUserByLoginName/{loginName}")
    @ResponseBody
    public Map<String,Object> getUserByName(@PathVariable String loginName){
        Map<String,Object> result = new HashMap<String, Object>();
        User user = userService.readByLoginName(loginName);
        Assert.notNull(user);
        result.put("name", user.getName());
        result.put("loginName", user.getLoginName());
        result.put("departmentName",user.getDepartment().getName());
        result.put("roleName", user.getRoleList().get(0).getName());
        return result;
    }
}

 

  JpaConfiguratioin.java

            package com.example;

import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.transaction.annotation.EnableTransactionManagement;



            /*
            * 
* @ClassName: JpaConfiguratioin 
* @Description: Jpa的配置类。
* @EnableTransactionManagement 启用了JPA 的事务管理
* @EnableJpaRepositories 启用了JPA资源库并指定了上面定义的接口资源库的位置
* @EntityScan 指定了定义实体的位置
* @author mengfanzhu
* @date 2017年2月20日 下午7:21:39 

            */
            
@Order(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@EnableTransactionManagement(proxyTargetClass = true)
@EnableJpaRepositories(basePackages = "com.example.dao")
@EntityScan(basePackages = "com.example.entity")
publicclass JpaConfiguratioin {

    @Bean
    PersistenceExceptionTranslationPostProcessor persistenceExceptionTranslationPostProcessor(){
        returnnew PersistenceExceptionTranslationPostProcessor();
    }
}

 

5.运行＋SpringBoot热部署  

<!-- springboot 热部署 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional><!-- optional=true,依赖不会传递，该项目依赖devtools；之后依赖myboot项目的项目如果想要使用devtools，需要重新引入 -->
    </dependency>

至于如何访问就不用过多介绍了吧。参照SpringMVC 即可。

后续将介绍 SpringBoot 实践系列，敬请期待～～～

原文：http://www.cnblogs.com/cnmenglang/p/6420940.html

内容总结

以上是互联网集市为您收集整理的SpringBoot实践 - SpringBoot+mysql全部内容，希望文章能够帮你解决SpringBoot实践 - SpringBoot+mysql所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1147206.html

来源：【匿名】