SpringBoot【完整笔记】自动配置热部署日志的使用多环境配置 SpringBoot集成Thymeleaf 静态资源拦截器集成DataSource 集成MyBatis

最新推荐文章于 2024-05-11 10:53:44 发布

snailisBigbull

最新推荐文章于 2024-05-11 10:53:44 发布

阅读量478

点赞数

本文链接：https://blog.csdn.net/snailisBigbull/article/details/100822243

版权

spring家族下的项目官网 https://spring.io/projects

一、基本概念

全新的框架，简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式进行配置。开发人员不再需要定义样板化的配置。

二、Spring的回顾

AOP，面向切面编程。是对面向对象编程的一个补充，解决面向对象解决不到解决麻烦的东西，比如处理事务、日志、权限。能达到，代码的统一性，代码的解耦。
XML配置IOC
1、创建项目
2、导入Spring依赖
3、创建xml文件
4、创建一个MyBean
5、把MyBean在xml中配置
6、测试：获取容器，获取MyBean

三、注解式编程

Anno配置IOC
1、创建Spring配置类
2、在配置类中定义Bean
3、测试类下·

一.SpringBoot介绍

1.SpringBoot基本概念

Spring Boot是其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。

2.回顾Spring的IOC,DI,AOP

IOC基本概念

inversion of control 从字面意思解释就是，控制反转。这里是指将Bean对象交给Spring容器来管理，以前呢，我们都是new对象，现在我们把控制权反转了，将它交给spring来管理，降低了代码的耦合度。

DI基本概念

依赖注入。它也是依赖注入的一种体现，比如说，现在有两个对象A和B，其中A对象中的一个属性是B对象，那么通过spring的控制反转就将B对象注入到A对象的属性中。这样的过程就是依赖注入

AOP基本概念

它不是一个技术，而是一种面向切面编程的思想，它的对oop面向对象编程思想的完善，它可以完成oop不能完成或者完成起来麻烦的事情，比如说，事务，在service业务层，我们要处理一些业务逻辑，要添加事务，需要在每一个对象每一个Controller都需要写开启事务，执行逻辑代码，提交事务，这样代码就很重复，又不得不重复，oop的思想此时就不能解决这个问题了，所以出现了AOP面向切面编程的思想，它是通过横切技术和动态代理，对公共代码的抽取，实现了代码的解耦。AOP呢，一般应用场景有，日志、事务、异常、验证等。

一.Spring回顾

XML配置IOC

1.创建项目

2.导入Spring依赖

在这里插入图片描述

<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.3.12.RELEASE</version>
</dependency>

3.创建xml配置文件

在这里插入图片描述

4.创建一个MyBean

在这里插入图片描述

5.把MyBean在xml中配置

在这里插入图片描述

6.测试

在这里插入图片描述

加载xml配置，获取容器，获取MyBean (ClassPathXmlApplicationContext)

二.Spring的注解配置

一.Anno配置IOC

1.创建Spring的配置类

Spring的配置类 ApplicationConfig.java 相当于是：applicationContext.xml

/**
 * Spring的配置类 相当于是：applicationContext.xml
 * @Configuration :Spring的配置标签，标记改类是Spring的配置类
 */
@Configuration		
public class ApplicationConfig {
}

2.在配置类中定义Bean

ApplicationConfig.java

/**
 * Spring的配置类 相当于是：applicationContext.xml
 * @Configuration :Spring的配置标签，标记改类是Spring的配置类
 */
@Configuration
public class ApplicationConfig {

    /**
     * @Bean : Spring的bean的定义标签 ，标记方法返回的对象交给Spring容器管理
     */
    @Bean
    public MyBean myBean(){
        return new MyBean();
    }

}

3.测试

加载配置类，获取容器，获取MyBean

@Test
    public void test(){
        //加载配置文件，拿到Spring容器
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(ApplicationConfig.class);

        //通过容器获取Mybaean
        MyBean bean = applicationContext.getBean(MyBean.class);
        System.out.println(bean);
    }

二.ComponentScan&ComponentScans自动扫描

1.准备MyBean帖@Component

@Component
public class MyBean {
}

2.创建配置类，帖@ComponentScan

@Configuration
//@ComponentScans
@ComponentScan("包名")
public class ApplicationConfig {
}

ComponentScan是ioc组件自动扫描，相当于是之前xml中 context:component-scan base-package=*

默认扫描当前包，及其子包；
在这里插入图片描述

ComponentScan.lazyInit :懒初始化

ComponentScan.excludeFilters :排除

注意：如果使用了自动扫描，那么配置类中就不要去配置@Bean

3.bean的详解

bean的id: 方法名
bean的name:可以通过 @Bean标签的name属性指定
生命周期方法：initMethod ， destroyMethod
单利多利： @Scope(“prototype”)
懒初始化: @Lazy

第三方Bean的注入方式

在这里插入图片描述

 @Bean(name="" , initMethod ="" ,destroyMethod="" )
 //@Scope("prototype")
 //@Lazy
 public MyBean myBean(){
 	return new MyBean();
 }

三.依赖注入

1.手动定义bean的方式

直接通过调方法的方式注入bean,或者通过参数注入bean

2.自动扫描定义bean的方式

使用 @Autowired 注入

  /**
     * @Bean : Spring的bean的定义标签 ，标记方法返回的对象交给Spring容器管理
     *  bean的id:  方法名 myBean
     *  bean的name:可以通过 @Bean标签的name属性指定
     *  生命周期方法：initMethod（初始方法） ， destroyMethod（销毁方法）
     * 要测试销毁方法，需要正常销毁，要用到spring的test环境	
     *  单利多利： @Scope("prototype")
     */
    @Bean(initMethod = "init" , destroyMethod = "destroy")
    public MyBean myBean(OtherBean otherBean){
        MyBean myBean = new MyBean();
        myBean.setName("娃娃");
        //myBean.setOtherBean(otherBean());
        myBean.setOtherBean(otherBean);
        return myBean ;
    }

    @Bean
    //@Lazy  //没有使用ComponentScan标签，要用懒加载就直接加@Lazy
    public OtherBean otherBean(){
        return new OtherBean();
    }

四.条件Conditional

Conditional注解帖在bean的定义方法上来判断，如果不满足条件就不会定义bean

1.在Bean的定义方法帖@Conditional

    @Bean
    @Conditional(value = MyCondition.class)
    public MyBean windowsMyBean(){
        return new MyBean("windowMyBean");
    }
    @Bean
    @Conditional(value = LinuxCondition.class)
    public MyBean linuxMyBean(){
        return new MyBean("linuxMyBean");
    }

2.定义条件类

public class MyCondition implements Condition {

    /**
     * 匹配方法，返回值决定是否满足条件
     */
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //获取系统环境   os.name 可以获取系统的名字
        String systemName = context.getEnvironment().getProperty("os.name");

        if("Windows 10".equals(systemName)){
            return true;
        }
        return false;
    }
}

public class LinuxCondition implements Condition {

    /**
     * 匹配方法，返回值决定是否满足条件
     */
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //获取系统环境   os.name 可以获取系统的名字
        String systemName = context.getEnvironment().getProperty("os.name");

        if("Linux".equals(systemName)){
            return true;
        }
        return false;
    }
}

五.@Import

1.直接导入Bean或者配置类

@Configuration
@Import(ApplicationOtherConfig.class)	//导入其他的配置类
public class ApplicationConfig

2.导入ImportSelector

定义ImportSelector

public class MyImportSelector implements ImportSelector {

    //选择导入，该方法返回我们需要导入的类的全限定名
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{
                "cn.itsource._07_import_selector.MyBean",
                "cn.itsource._07_import_selector.OtherBean"};
    }
}

@Configuration
@Import(MyImportSelector.class)	//导入选择器
public class ApplicationConfig

3.导入ImportBeanDefinitionRegistrar

定义 ImportBeanDefinitionRegistrar

public class MyBeanRegistor implements ImportBeanDefinitionRegistrar {
    //注册bean ， BeanDefinitionRegistry ：注册bean的注册器
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

        //参数：beanName ：bean的名字
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(MyBean.class);
        registry.registerBeanDefinition("myBean",rootBeanDefinition );
    }
}

@Configuration
@Import(MyBeanRegistor.class)	//导入bean注册器
public class ApplicationConfig

六.FactoryBean

通过工厂定义bean

1.定义FactoryBean

public class MyBeanFactoryBean implements FactoryBean<MyBean> {
    public MyBean getObject() throws Exception {
        return new MyBean();
    }

    public Class<?> getObjectType() {
        return MyBean.class;
    }

    public boolean isSingleton() {
        return true;
    }
}

2.配置 MyBeanFactoryBean的bean定义

@Configuration
public class ApplicationConfig {

    @Bean
    public MyBeanFactoryBean myBean(){
        return new MyBeanFactoryBean();
    }
}

3.测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes ={ ApplicationConfig.class})
public class AnnoTest {
    @Autowired
    private MyBean myBean;

    @Test
    public void test(){
        System.out.println(myBean);
    }
}

七.Bean生命周期

1.Bean+InitMethod+DestoryMethod

@Bean(InitMethod="" , DestoryMethod="")

2.InitializingBean, DisposableBean

public class MyBean implements InitializingBean, DisposableBean {
    public MyBean(){
        System.out.println("创建.............");
    }
    public void destroy() throws Exception {
        System.out.println("destroy方法...........");
    }
    public void afterPropertiesSet() throws Exception {
        System.out.println("初始化方法...........");
    }
}

在这里插入图片描述

是javax中的注解

@PostConstruct

@PreDestroy

3.PostConstruct+PreDestroy

@Component
public class MyBean {

    @PostConstruct
    public void init(){
        System.out.println("init.....");
    }
    @PreDestroy
    public void destory(){
        System.out.println("destory.....");
    }
}

4.BeanPostProcessor后置处理器

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化之前.....:"+bean);
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("初始化之后.....:"+bean);
        return bean;
    }
}

三.SpringBoot-HelloWorld

一.HelloWorld

1.HelloWorld-web应用

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.5.RELEASE</version>
  </parent>

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

2.创建配置类

@SpringBootApplication
public class ApplicationConfig {

    public static void main(String[] args) {
        SpringApplication.run(ApplicationConfig.class);
    }
}

3.编写Controller

@Controller
public class Example {

	@RequestMapping("/")
	@ResponseBody
	String home() {
		return "Hello World!";
	}
}

二.HelloWorld-web应用分析

疑惑的点

spring-boot-starter-parent ：SpringBoot的父工程，帮我们管理了很多的基础jar包
spring-boot-starter-web ：SpringBoot和SpringMvc整合的jar包，并且导入了日志，tomcat,json等等相关的jar包
RestController : Controller+ResponseBody
@EnableAutoConfiguration : 开启自动配置功能
SpringApplication.run ：启动SpringBoot应用
jar ：SpringBoot应用默认打jar包
SpringBootApplication：包括三个标签组成

@SpringBootConfiguration - @Configuration ： Spring的配置标签

@EnableAutoConfiguration ：开启自动配置

@ComponentScan ：组件自动扫描

在这里插入图片描述

dependencyManagement

该标签下的jar包，默认是不能被子项目直接使用的，他只有声明的功能，如果子项目想用这里标签里面的jar包，需要显示的写出来，而版本号使用父工程的。达到版本号统一管理的效果

dependencies

这个标签下面的jar包默认会被子项目直接继承直接使用

四.SpringBoot的特点
1.使用注解配置，无需xml（简单粗暴）

2.快速搭建，开发

3.简化的maven

4.方便的和三方框架集成

5.内嵌tomcat,部署简单

6.内置健康检查，监控等

7.自动配置，让配置更加简单

五.SpringBoot基本使用
一.项目结构
src
–main
–java
–resources
–static //静态资源目录
–templates //模板页面目录，如：jsp ,ftl
–application.properties/application.yml //默认配置文件
二.独立运行
1.导入打包插件

org.springframework.boot
spring-boot-maven-plugin

2.打包
在这里插入图片描述

java -jar xxx.jar

三.热部署

1.导入依赖

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

2.编译代码

ctrl + F9

3.配置IDEA的自动编译功能

配置setting的自动编译
在这里插入图片描述

按 ctrl +shift + alt + / -> registry -> 如下

在这里插入图片描述

四.yml基本语法

多个级之间用：分类，并且换行缩进，值不用换行，值前面有个空格

五.SpringBoot读取配置

一.使用@Value标签

配置文件

user:
  username: ls
  password: 456
  age: 99

绑定配置的对象

@Component
public class User {

    //@Value :从配置文件中取值   SPEL
    @Value("${user.username}")
    private String username = "zs";

    @Value("${user.password}")
    private String password = "123";

    @Value("${user.age}")
    private int age = 18;
    . . . . . .

二.使用@ConfigurationProperties

配置文件

employee:
  username: ls
  password: 456
  age: 99

绑定配置的对象

@Component
@ConfigurationProperties(prefix = "employee")
public class Employee {
    private String username = "zs";
    private String password = "123";
    private int age = 18;
@ConfigurationProperties : 自动的根据前缀从配置中过滤出配置项目，然后根据当前对象的列名进行匹配，自动赋值

六.多环境配置切换

1.方式一

spring:
  profiles:
    active: test    #激活(选择)环境test
---
spring:
  profiles: dev     #指定环境名字dev
server:
  port: 9999
---
spring:
  profiles: test    #指定环境名字test
server:
  port: 8888

2.方式二

通过配置文件的名字来识别环境

application-dev.yml

server:
  port: 9999

application-test.yml

server:
  port: 8888

application.yml

spring:
  profiles:
    active: test 
    #根据文件名字配置 application-dev.properties

七.日志的使用

1.基本使用

private Logger logger = LoggerFactory.getLogger(MySpringBootTest.class);

...
 logger.error("我是一个error日志.....");
 logger.warn("我是一个warn日志.....");
 logger.info("我是一个info日志.....");

logger.debug("我是一个debug日志.....");
logger.trace("我是一个trace日志.....");

2.配置日志

#logging.level.cn.itsource=error
#logging.file=my.txt
#logging.file.max-size=1KB
#logging.pattern.console="%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n"

3.指定配置文件配置logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- 定义常量 ： 日志格式 -->
    <property name="CONSOLE_LOG_PATTERN" value="%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%n"/>

    <!--ConsoleAppender 用于在屏幕上输出日志-->
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <!--定义控制台输出格式-->
        <encoder>
            <pattern>${CONSOLE_LOG_PATTERN}</pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>

    <!--打印到文件-->
    <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">

        <file>logs/springboot.log</file>

        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>logs/springboot-%d{yyyyMMdd}-%i.log.gz</fileNamePattern>
            <maxFileSize>1KB</maxFileSize>
            <maxHistory>30</maxHistory>
            <!--总上限大小-->
            <totalSizeCap>5GB</totalSizeCap>
        </rollingPolicy>
        <!--定义控制台输出格式-->
        <encoder>
            <pattern>${CONSOLE_LOG_PATTERN}</pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>


    <!--root是默认的logger 这里设定输出级别是debug-->
    <root level="info">
        <!--定义了两个appender，日志会通过往这两个appender里面写-->
        <appender-ref ref="stdout"/>
        <appender-ref ref="file"/>
    </root>

    <!--如果没有设置 additivity="false" ,就会导致一条日志在控制台输出两次的情况-->
    <!--additivity表示要不要使用rootLogger配置的appender进行输出-->
    <logger name="cn.itsource" level="error" additivity="false">
        <appender-ref ref="stdout"/>
        <appender-ref ref="file"/>
    </logger>

</configuration>

八.SpringBoot集成Thymeleaf

1.模板引擎的原理
2.jsp的原理

集成Thymeleaf

1.导入依赖

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

2.创建模板 resources/templates/hello.html

<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>成功！</h1>
    <!--使用语法th:text 将div里面的文本内容设置为 -->

    <div th:text="${msg}">这是显示欢迎信息</div>
</body>
</html>

3.编写controller

@Controller
public class HelloController {
    @RequestMapping("/index")
    public String hello(Model model){
        model.addAttribute("msg","后面有人,认真听课" );
        return "hello";
    }
}

4.编写主配置类

5.Thymeleaf的自动配置原理

@EnableAutoConfiguration 开启自动配置功能，通过一个AutoConfigurationImportSelector导入选择器去扫描 spring-boot-autoconfigure-2.0.5.RELEASE.jar 自动配置包下面的 spring.factories 文件中的很多很多的自动配置的类
而：ThymeleafAutoConfiguration 是的Thymeleaf的自动配置，在这个自动配置类里面通过一个ThymeleafProperties去读取配置文件中的配置(也有默认配置) ，来自动配置Thymeleaf，比如Thymeleaf的视图解析器的自动配置如下：

@Bean
@ConditionalOnMissingBean(name = "thymeleafViewResolver")
public ThymeleafViewResolver thymeleafViewResolver() {
    ThymeleafViewResolver resolver = new ThymeleafViewResolver();
    ...
    return resolver;
}

6.Thymeleaf的语法

下去找时间看

九.静态资源

1.静态资源目录

resource/static

2.webjars

导入jquery依赖（ http://www.webjars.org/）

<dependency>
    <groupId>org.webjars</groupId>
    <artifactId>jquery</artifactId>
    <version>3.4.1</version>
</dependency>

导入jquery的js

<script src="/webjars/jquery/3.4.1/jquery.js"></script>

3.首页

resources/index.html

4.图标

resources/favicon.ico

十.SpringBoot中的MVC配置

1.配置拦截器

定义拦截器

@Component
public class MyHandlerInterceptor extends HandlerInterceptorAdapter {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle................:"+request.getRequestURI());
        return super.preHandle(request, response, handler);
    }
}

注册拦截器

@SpringBootApplication
public class ApplicationConfig implements WebMvcConfigurer {

    @Autowired
    private MyHandlerInterceptor myHandlerInterceptor;
    /**
     * 注册拦截器
     * @param registry ：拦截器的注册器
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myHandlerInterceptor).addPathPatterns("/**").excludePathPatterns("/login");
    }
@SpringBootApplication
public class ApplicationConfig implements WebMvcConfigurer {

    @Autowired
    private MyHandlerInterceptor myHandlerInterceptor;
    /**
     * 注册拦截器
     * @param registry ：拦截器的注册器
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myHandlerInterceptor).addPathPatterns("/**").excludePathPatterns("/login");
    }

2.添加视图控制器

@Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/xx").setViewName("hello2.html");
    }

当访问/xx 定位到 templates/hello2.html

十一.集成DataSource

1.导入依赖

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.20</version>
        </dependency>
        <!-- mysql 数据库驱动. -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>

2.手动配置方式

手动配置四个属性

 /* jdbc:
   		username: root
   		password: 123456
    	url: jdbc:mysql:///ssm
    	driver-class-name: com.mysql.jdbc.Driver
    */
    @Bean
    @ConfigurationProperties(prefix = "jdbc")
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        return dataSource ;
    }

3.自动配置方式 - 重点

spring:
  	datasource:
    	username: root
    	password: 123456
    	url: jdbc:mysql:///ssm
    	driver-class-name: com.mysql.jdbc.Driver
   		type: com.alibaba.druid.pool.DruidDataSource

十二.集成MyBatis

1.导入依赖

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

2.配置Mybatis

mybatis:
  mapper-locations: classpath:cn/itsource/mapper/*Mapper.xml

3.配置Mapper接口扫描包

@SpringBootApplication
@MapperScan("cn.itsource.web.controller.mapper")
public class ApplicationConfig {
   ...
}

十三.集成事务

1.使用注解方式

开启事务管理器

@SpringBootApplication
@MapperScan("cn.itsource.web.controller.mapper")
@EnableTransactionManagement
public class ApplicationConfig{
...}
service打事务标签

@Transactional
@Service
public class EmployeeServiceImpl

2.使用xml方式配置

导入依赖

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

配置事务xml

<!-- 配置事物管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

    <aop:config>
        <aop:pointcut expression="execution(* cn.itsource.web.controller.service..*.*(..))" id="coreServicePointcut"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="coreServicePointcut"/>
    </aop:config>

    <!-- aop应用事务管理 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="select*" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED" />
        </tx:attributes>
    </tx:advice>

导入xml配置

@ImportResource("classpath:applicationContext-service.xml")
public class ApplicationConfig

十四.PageHelper的使用

官方网站：

https://github.com/abel533/MyBatis-Spring-Boot

1.导入依赖

<dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
</dependency>

#pagehelper
pagehelper:
  helperDialect: mysql
  reasonable: true
  supportMethodsArguments: true
  params=count: countSql

2.编写查询语句
xxxMapper.xml

<select id="selectPage" resultType="cn.itsource.web.controller.domain.Employee">
    select id,username,realName from t_employee
</select>

注意:用了pagehelper之后，查询总条数的sql不用写， limit 不用写，如上：

3.查询的service

 @Override
    public Page<Employee> selectPage() {
        PageHelper.startPage(1,5 );
        Page<Employee> page = (Page<Employee>) employeeMapper.selectPage();
        return  page;
    }

PageHelper.startPage(1,5 )：设置当前页和每页条数

Page ：是pagehelper自己封装的页面对象，如同我们以前的PageList ,里面有总条数，列表，总页数等等

4.获取结果

 Page<Employee> page = employeeService.selectPage();
 System.out.println("总条数:"+page.getTotal());
 for (Employee employee : page.getResult()) {
    System.out.println(employee);
 }

今天作业

1.全天代码

2.编码规范

包名全小写，多个单词用_分开；类名首字母大写，驼峰；方法名首字母小写，驼峰

3.补全课堂笔记

今天重点

1.Spring注解配置

(重点)_02_anno_ioc
(重点)_03_anno_scan
_04_bean_detail
_05_condition
(重点)_06_import
_07_import_selector
_08_improt_registry
_09_factorybean
_10_initializingbean_disposablebean
_11_postconstract_predestory
_12_beanpostprocessor

2.SpringBoot Hello-world(重点中的重点)

3.SpringBoot-Hello-World分析(重点中的重点)

四、 Spring入门

五、SpringBoot高级

六、SpringBoot拓展

snailisBigbull

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot【完整笔记】自动配置热部署日志的使用多环境配置 SpringBoot集成Thymeleaf 静态资源拦截器集成DataSource 集成MyBatis

一、基本概念全新的框架，简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式进行配置。开发人员不再需要定义样板化的配置。二、Spring的回顾AOP，面向切面编程。是对面向对象编程的一个补充，解决面向对象解决不到解决麻烦的东西，比如处理事务、日志、权限。能达到，代码的统一性，代码的解耦。XML配置IOC1、创建项目2、导入Spring依赖3、创建xml文件4、创建一...
复制链接

扫一扫