maven +SpringBoot+restful+mySql

爱被打了一巴掌 2022-06-13 06:16 73阅读 0赞

# 我们创建一个maven +SpringBoot+restful+mySql的项目，这个是目录结构！我么要注意，一定要将 **main **方法的与  controller  文件夹放在同一级目录下 #

![Image 1][]![Center][]

## 第一步  配置 pom.xml源码 如下 ##

<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>sy.testboot</groupId>  
<artifactId>Boot</artifactId>  
<packaging>war</packaging>  
<version>0.0.1-SNAPSHOT</version>  
<name>Boot Maven Webapp</name>  
<url>http://maven.apache.org</url>  
<parent>  
<groupId>org.springframework.boot</groupId>  
<artifactId>spring-boot-starter-parent</artifactId>  
<version>1.5.2.RELEASE</version>  
</parent>  
<dependencies>  
<dependency>  
<groupId>org.springframework.boot</groupId>  
<artifactId>spring-boot-starter-web</artifactId>  
<version>1.3.0.RELEASE</version>  
</dependency>  
<dependency>  
<groupId>org.springframework.boot</groupId>  
<artifactId>spring-boot-starter-data-jpa</artifactId>  
<version>1.3.0.RELEASE</version>  
</dependency>  
<dependency>  
<groupId>mysql</groupId>  
<artifactId>mysql-connector-java</artifactId>  
<version>5.1.37</version>  
</dependency>  
</dependencies>  
</project>

## 第二步 配置application.properties ##

\# Database  
spring.datasource.url=jdbc:mysql://localhost:3306/test  
spring.datasource.username=root  
spring.datasource.password=admin  
spring.datasource.driver-class-name=com.mysql.jdbc.Driver  
\# Hibernate  
hibernate.dialect: org.hibernate.dialect.MySQL5Dialect  
hibernate.show\_sql: true  
hibernate.hbm2ddl.auto: update  
entitymanager.packagesToScan: netgloo

## 第四步  写主方法 TestBoot.java ##

package sy.testboot;  
  
  
import org.springframework.boot.SpringApplication;  
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;  
import org.springframework.context.annotation.ComponentScan;  
import org.springframework.context.annotation.Configuration;  
import org.springframework.stereotype.Controller;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RequestMethod;  
import org.springframework.web.bind.annotation.ResponseBody;  
  
  
  
  
  
  
@Controller  
@ComponentScan    
@Configuration    
@EnableAutoConfiguration  
public class TestBoot \{  
  
  
@RequestMapping(value = "/hello", method = RequestMethod.GET)  
@ResponseBody  
public String hello() \{  
     return "hello world";  
\}  
  
public static void main(String\[\] args) \{  
SpringApplication.run(TestBoot.class, args);  
\}  
  
  
\}

##    接下来 UserController.java ##

package sy.testboot.controllers;  
  
  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.boot.autoconfigure.SpringBootApplication;  
import org.springframework.web.bind.annotation.PathVariable;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RequestMethod;  
import org.springframework.web.bind.annotation.ResponseBody;  
import org.springframework.web.bind.annotation.RestController;  
  
  
import sy.testboot.models.User;  
import sy.testboot.models.UserDao;  
  
  
  
  
//表明某类是一个控制器    控制请求  
@RestController  
@SpringBootApplication  
@RequestMapping(value = "/create")  
public class UserController \{  
  
  
// 1、请求的映射规则 value是规则的值 2、该注解用于读取Request请求的body部分数据  
  
  
@RequestMapping(value = "/\{email\}/\{name\}",method = RequestMethod.GET)  
public String create(@PathVariable(value="email") String email,@PathVariable(value="name") String name) \{  
try \{  
User user = new User();  
user.setEmail(email);  
user.setName(name);  
userDao.create(user);  
\} catch (Exception ex) \{  
return "添加用户失败: " + ex.toString();  
\}  
 return "添加成功";  
\}  
  
  
@RequestMapping(value = "/delete/\{id\}")  
@ResponseBody  
public String delete(@PathVariable(value="id") long id) \{  
try \{  
User user = new User();  
user.setId(1L);  
userDao.delete(user);  
\} catch (Exception ex) \{  
return "删除用户失败: " + ex.toString();  
\}  
return "删除成功";  
\}  
  
  
@RequestMapping(value = "/check/\{email\}",method = RequestMethod.GET)  
public String getByEmail(@PathVariable(value="email") String email) \{  
System.out.println("check");  
String userId;  
try \{  
System.out.println(email);  
User user = userDao.getByEmail(email);  
userId = String.valueOf(user.getId());  
\} catch (Exception ex) \{  
return "查询失败: " + ex.toString();  
\}  
return "用户ID: " + userId;  
\}  
  
  
@RequestMapping(value = "/update")  
@ResponseBody  
public String updateName(long id, String email, String name) \{  
try \{  
User user = userDao.getById(id);  
user.setEmail(email);  
user.setName(name);  
userDao.update(user);  
\} catch (Exception ex) \{  
return "修改失败: " + ex.toString();  
\}  
return "修改成功";  
\}  
  
  
// 自动注入  
@Autowired  
private UserDao userDao;  
  
  
\}

## user.java ##

package sy.testboot.models;  
  
  
import java.io.Serializable;  
  
  
import javax.persistence.Entity;  
import javax.persistence.GeneratedValue;  
import javax.persistence.GenerationType;  
import javax.persistence.Id;  
import javax.persistence.Table;  
import javax.validation.constraints.NotNull;  
  
  
//1、实体注解     2、对应数据库的哪张表  
@Entity  
@Table(name = "user")  
public class User implements Serializable \{  
  
  
// @Id 注解可将实体Bean中某个属性定义为主键  
// @GeneratedValue 表示该表主键生成策略 strategy策略 GenerationType策略类型 IDENTITY自增  
// AUTO自动选择 SEQUENCE通过序列 TABLE通过表产生主键  
@Id  
@GeneratedValue(strategy = GenerationType.AUTO)  
private long id;  
  
  
// 注解表示该字段是非空的  
@NotNull  
private String email;  
  
  
@NotNull  
private String name;  
  
  
public User() \{  
\}  
  
  
public User(long id) \{  
this.id = id;  
\}  
  
  
  
  
public long getId() \{  
return id;  
\}  
  
  
public void setId(long id) \{  
this.id = id;  
\}  
  
  
public String getEmail() \{  
return email;  
\}  
  
  
public void setEmail(String email) \{  
this.email = email;  
\}  
  
  
public String getName() \{  
return name;  
\}  
  
  
public void setName(String name) \{  
this.name = name;  
\}  
  
  
\}

## UserDao.java ##

package sy.testboot.models;  
  
  
import java.util.List;  
  
  
import javax.persistence.EntityManager;  
import javax.persistence.PersistenceContext;  
import javax.transaction.Transactional;  
  
  
import org.springframework.stereotype.Repository;  
  
  
//1、存储层Bean的注解    2、声明这个类的所有方法需要事务管理  
@Repository  
@Transactional  
public class UserDao \{  
  
  
/\*\*  
\* 实体管理器，执行持久化操作 添加  
\*/  
public void create(User user) \{  
String sql ="insert into User  values((SELECT REPLACE(UUID(),'-','')),'"+user.getEmail()+"','"+user.getName()+"')";  
javax.persistence.Query query = entityManager.createNativeQuery(sql);  
query.executeUpdate();  
  
\}  
  
  
  
/\*\*  
\* 实体管理器，执行持久化操作 删除  
\*/  
public void delete(User user) \{  
if (entityManager.contains(user))  
entityManager.remove(user);  
else  
entityManager.remove(entityManager.merge(user));  
return;  
\}  
  
  
/\*\*  
\* 实体管理器，执行持久化操作 查询所有数据  
\*/  
@SuppressWarnings("unchecked")  
public List<User> getAll() \{  
return entityManager.createQuery("from User").getResultList();  
\}  
  
  
/\*\*  
\* 实体管理器，执行持久化操作 根据email查询User对象  
\*/  
public User getByEmail(String email) \{  
return (User) entityManager  
.createQuery("from User where email = :email")  
.setParameter("email", email).getSingleResult();  
\}  
  
  
/\*\*  
\* 实体管理器，执行持久化操作 根据ID查询User对象  
\*/  
public User getById(long id) \{  
return entityManager.find(User.class, id);  
\}  
  
  
/\*\*  
\* 实体管理器，执行持久化操作 修改  
\*/  
public void update(User user) \{  
entityManager.merge(user);  
return;  
\}  
  
  
// 注入实体管理器  
@PersistenceContext  
private EntityManager entityManager;  
//实体管理  
  
  
\}

## DatabaseConfig.java ##

package sy.configs;  
  
  
import java.io.IOException;  
import java.util.Properties;  
  
  
import javax.sql.DataSource;  
  
  
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
import org.springframework.core.env.Environment;  
import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;  
import org.springframework.jdbc.datasource.DriverManagerDataSource;  
import org.springframework.orm.jpa.JpaTransactionManager;  
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;  
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;  
import org.springframework.transaction.annotation.EnableTransactionManagement;  
  
  
@Configuration  
@EnableTransactionManagement  
public class DatabaseConfig \{  
  
  
/\*\*  
\* DataSource definition for database connection. Settings are read from the  
\* application.properties file (using the env object).  
\*/  
@Bean  
public DataSource dataSource() \{  
// 数据连接池对象  
DriverManagerDataSource dataSource = new DriverManagerDataSource();  
// 获取数据源连接池中的数据(resources中的数据连接文件)  
dataSource.setDriverClassName(env.getProperty("db.driver"));  
dataSource.setUrl(env.getProperty("db.url"));  
dataSource.setUsername(env.getProperty("db.username"));  
dataSource.setPassword(env.getProperty("db.password"));  
// 返回一个数据源  
return dataSource;  
\}  
  
  
/\*\*  
\* Declare the JPA entity manager factory.  
\*/  
@Bean  
public LocalContainerEntityManagerFactoryBean entityManagerFactory()  
throws IOException \{  
LocalContainerEntityManagerFactoryBean entityManagerFactory = new LocalContainerEntityManagerFactoryBean();  
  
  
entityManagerFactory.setDataSource(dataSource);  
  
  
// Classpath scanning of @Component, @Service, etc annotated class  
entityManagerFactory.setPackagesToScan("sy.models");  
  
  
// Vendor adapter  
HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();  
entityManagerFactory.setJpaVendorAdapter(vendorAdapter);  
  
  
// Hibernate properties  
Properties additionalProperties = new Properties();  
additionalProperties.put("hibernate.dialect",  
env.getProperty("hibernate.dialect"));  
additionalProperties.put("hibernate.show\_sql",  
env.getProperty("hibernate.show\_sql"));  
additionalProperties.put("hibernate.hbm2ddl.auto",  
env.getProperty("hibernate.hbm2ddl.auto"));  
entityManagerFactory.setJpaProperties(additionalProperties);  
  
  
return entityManagerFactory;  
\}  
  
  
/\*\*  
\* Declare the transaction manager.  
\*/  
@Bean  
public JpaTransactionManager transactionManager() \{  
JpaTransactionManager transactionManager = new JpaTransactionManager();  
transactionManager.setEntityManagerFactory(entityManagerFactory  
.getObject());  
return transactionManager;  
\}  
  
  
/\*\*  
\* PersistenceExceptionTranslationPostProcessor is a bean post processor  
\* which adds an advisor to any bean annotated with Repository so that any  
\* platform-specific exceptions are caught and then rethrown as one Spring's  
\* unchecked data access exceptions (i.e. a subclass of  
\* DataAccessException).  
\*/  
@Bean  
public PersistenceExceptionTranslationPostProcessor exceptionTranslation() \{  
return new PersistenceExceptionTranslationPostProcessor();  
\}  
  
  
// Private fields  
  
  
// 用于获取数据源环境的对象(resources数据连接的配置文件)  
@Autowired  
private Environment env;  
  
  
@Autowired  
private DataSource dataSource;  
  
  
@Autowired  
private LocalContainerEntityManagerFactoryBean entityManagerFactory;  
  
  
\}

### 下边有整个项目完整源码：百度云盘 http://pan.baidu.com/s/1gfL2223 ###

[Image 1]: 
[Center]: /images/20220613/1b76a6dcb26544d2bf2b6a3edfa828b9.png