springboot项目创建流程及连接数据库

最新推荐文章于 2024-05-21 21:35:57 发布

6x6x6x

最新推荐文章于 2024-05-21 21:35:57 发布

阅读量633

点赞数

文章标签： spring boot mybatis

本文链接：https://blog.csdn.net/x6x6x6x/article/details/104603497

版权

springboot项目创建流程

以idea为例 :

新建一个maven项目

在pom.xml文件里面添I加springboot父依赖，表明这是一个springboot项目（需添加version版本信息）

<!-- 定义公共资源版本 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

再添加一个web启动器依赖，这里不需要版本信息，因为在父依赖中已经将所有的版本信息都配置好了，使用统一的版本。（这里面集成了tomcat）

 <!-- 包含 mvc,aop 等jar资源 -->

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

定义一个启动类，因为集成了tomcat，没有启动的地方，需自己定义启动的地方。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    //启动类 固定写法
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

之后就可定义Controller，service ， mapper等

package Controller;

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

@Controller
@RequestMapping("test")
public class TestController {
    @RequestMapping("hello")
    @ResponseBody
    public String sayTest () {
        return "hello world" ;
    }
}

然后在启动类运行，即可在网页访问（http://localhost：8080/test/hello）。

这里注意一个问题：

你的项目一定不要直接放在最上层的那个Java目录下，可以用一个包包装，不然tomcat启动不了。

springboot中的java配置

springMVC的方式:

在resources（资源文件）中新建一个jdbc.properties

jdbc.driverClassName = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/test
jdbc.username = root
jdbc.password = root

新建一个jdbcConfig类(配置类)，添加@Configuration

在类中添加属性 url、username、paassword、driverClassName

在类添加注释@PropertySource(“classpath : jdbc.properties”)

给属性添加@Value(“${jdbc.url}”)等
在定义一个getDataSource方法，将属性注入到DataSource中，将其返回出去。@bean就会将其注入IOC容器。

代码如下：

package Config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;

@Configuration
@PropertySource("classpath : jdbc.properties")
public class jdbcConfig {
    @Value("${jdbc.driverClassName}")
    private String driverClassName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;


    /**
     * 获取连接，返回
     * @return
     */
    @Bean
    public DataSource getDataSource () {
        //注意添加druid数据源(百度搜索maven)
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

在Controller中定义一个pravite DataSource ds；在这个属性上添加@Autowired,从IOC容器获取DataSource对象，可以打印测试。

springboot：

新建一个application.yml文件

jdbc: 
	driverClassName: com.mysql.jdbc.Driver
	url: jdbc:mysql://localhost:3306/test
	username: root
	password: root
	
---------------------------------------------------------------
这里面还可以配端口、路径
server: 
	port: 8089
	servlet: 
		path: /
spring: 
	datasource: 
		driverClassName: com.mysql.jdbc.Driver
		url: jdbc:mysql://localhost:3306/test
		username: root
		password: root

连接数据库：添加两个依赖

spring整合jdbc的
java连接数据库的

		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.1.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

新建一个jdbcConfig2类：

package Config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class jdbcConfig2 {
    @Bean
    @ConfigurationProperties(prefix = "datasource")//自动注入
    public DataSource getDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        return dataSource;
    }
}

这样也能获取连接。

springboot约定在resource目录下新建static文件夹下放img、js、css等静态文件

springboot拦截器

新建interceptor包

新建LoginInterceptor类实现HandlerInterceptor接口

重写方法：

1、preHandle(……) 方法
该方法的执行时机是，当某个 URL 已经匹配到对应的 Controller 中的某个方法，且在这个方法执行之前。所以 preHandle(……) 方法可以决定是否将请求放行，这是通过返回值来决定的，返回 true 则放行，返回 false 则不会向后执行。

2、postHandle(……) 方法
该方法的执行时机是，当某个 URL 已经匹配到对应的 Controller 中的某个方法，且在执行完了该方法，但是在 DispatcherServlet 视图渲染之前。所以在这个方法中有个 ModelAndView 参数，可以在此做一些修改动作。

3、afterCompletion(……) 方法
顾名思义，该方法是在整个请求处理完成后（包括视图渲染）执行，这时做一些资源的清理工作，这个方法只有在 preHandle(……) 被成功执行后并且返回 true 才会被执行。

LoginInterceptor代码：

public class LoginInterceptor implements HandlerInterceptor {

    private static final Logger logger = LoggerFactory.getLogger(LoginInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();
        String methodName = method.getName();
        logger.info("====拦截到了方法：{}，在该方法执行之前执行====", methodName);
        // 返回 true 才会继续执行，返回 false 则取消当前请求
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        logger.info("执行完方法之后进执行(Controller方法调用之后)，但是此时还没进行视图渲染");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        logger.info("整个请求都处理完咯，DispatcherServlet也渲染了对应的视图咯，此时我可以做一些清理的工作了");
    }
}

拦截器做好了，再进行配置，使其在spring中生效。

拦截器配置

因为是配置拦截器，属于配置，写在Config包下

新建一个MvcConfig.java

@Component    ？？？？

@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 实现 WebMvcConfigurer 不会导致静态资源被拦截
        // 这里配置的是全路径拦截
        registry.addInterceptor(new MvcConfig()).addPathPatterns("/**");
    }
}

然后，启动。

springboot整合Mybatis

首先导入mybatis的依赖：

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.2</version>
</dependency>

在application.yml文件中添加：

#配置别名
mybatis: 
	type-aliases-package: Springboot_demo01.pojo

添加通用mapper的依赖：

<dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper-spring-boot-starter</artifactId>
    <version>2.1.5</version>
</dependency>

新建一个pojo包，在pojo里面创建一个对应的数据库对象实体类

用@Table(name = “表名”)注解

对象的属性必须用包装类

主键用@Id注解 @GeneratedValue 自增长

数据库里面的属性为下划线时，改为驼峰式命名例： user_name 改为 userName

package Springboot_demo01.pojo;

import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Table(name = "test")
public class User {
    @Id
    @GeneratedValue
    private Long id;

    private String name;

    private String password;
}

在mapper层新建User Mapping接口继承Mapper<>.在启动器里面@MappingScan(“mapper”) 其意思为扫描mapper下的接口创建其实现类
在Controller层新建方法查询数据库

 	@GetMapping("/{id}")
	@ResponseBody
    public User queryUserById(@PathVariable("id") Long id){
        //@PathVariable 路径变量,获取传过来的id参数   
        User user = userService.selectUserById(id);
        return user;
    }

运行。

注：执行修改等操作须在service层的方法上添加@Transactional 手动注解开启事务

6x6x6x

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
springboot项目创建流程及连接数据库

springboot项目创建流程以idea为例 :新建一个maven项目在pom.xml文件里面添I加springboot父依赖，表明这是一个springboot项目（需添加version版本信息） <parent> <groupId>org.springframework.boot&lt...
复制链接

扫一扫