java面试问题整理

最新推荐文章于 2022-12-04 17:31:12 发布

当时的那个女孩

最新推荐文章于 2022-12-04 17:31:12 发布

阅读量221

点赞数

分类专栏： Java面试

本文链接：https://blog.csdn.net/qq_38990795/article/details/110518235

版权

Java面试专栏收录该内容

11 篇文章 0 订阅

订阅专栏

1、mapper接口类和mybatis实体配置xml之间有哪些对应关系

1.2 在使用mybatis的时候，我们只需要编写Dao层的mapper.java接口和mapper.xml文件。mybatis会根据UserMapper.xml中配置的信息创建一个实现了UserMaper.java接口的代理类(使用JDK动态代理);

因此在配置UserMapper.xml时会要求:

在UserMapper.xml中namespace等于UserMapper.java接口地址(即UserMapper的全限定名)；
UserMapper.java接口中的方法名和UserMapper.xml中的statement(<select>,<update>...标签)的id属性值一致;
UserMapper.java接口中的方法输入值参数和UserMapper.xml中statement的parameterType指定的类型一致。
UserMapper.java接口中的方法的返回值类型和UserMapper.xml中statement的resultType指定的类型一致。

1.2 Mybatis中接口和对应的mapper文件位置配置深入剖析

在典型的maven工程中，目录结构有：src/main/java和src/main/resources，前者是用来存放java源代码的，后者则是存放一些资源文件，比如配置文件等，在默认的情况下maven打包的时候，对于src/main/java目录只打包源代码，而不会打包其他文件。所以此时如果把对应的mapper文件放到src/main/java目录下时，不会打包到最终的jar文件夹中，也不会输出到target文件夹中，由于在进行单元测试的时候执行的是/target目录下/test-classes下的代码，所以在测试的时候也不会成功。
为了实现在maven默认环境下打包时，Mybatis的接口和mapper文件在同一包中，可以通过将接口文件放在src/main/java某个包中，而在src/main/resources目录中建立同样的包，这是一种约定优于配置的方式，这样在maven打包的时候就会将src/main/java和src/main/resources相同包下的文件合并到同一包中。

更改maven构建配置 如果不想将接口和mapper文件分别放到src/main/java和src/main/resources中，而是全部放到src/main/java，那么在构建的时候需要指定maven打包需要包括xml文件，具体配置如下：

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

接口和文件不在同一个包下

如果接口和mapper文件不在同一个包下，就不能进行自动扫描解析了，需要对接口和文件分别进行配置。

xml配置不使用spring，使用Mybatis的配置文件如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
  <mappers>
    <!-- 扫描路径下的mapper映射文件 -->
    <mapper resource="mappers/UserMapper.xml"/>
    <!-- 扫描包下的接口文件 -->
    <package name="edu.zju.bme.data.manage.mapper" />
  </mappers>
</configuration>

xml配置使用spring：

<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
  xsi:schemaLocation="
  http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring.xsd">
  <!-- 配置接口存储的包，用来扫描mapper接口 -->
  <mybatis:scan base-package="edu.zju.bme.data.manage.mapper" />
  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!-- 配置mapper文件位置，扫描映射文件，可以使用Ant风格的路径格式 -->
    <property name="mapperLocations" value="classpath*:mappers/**/*.xml" />
    // ...
  </bean>
</beans>

java配置使用spring配置：

// 配置类
@Configuration(value = "manageConfig")
@Import(value = {DataSourceConfig.class})
// 扫描接口类，这个配置只能扫描该包下的接口，不能扫描mapper文件
@MapperScan("edu.zju.bme.data.manage.mapper")
public class ManageConfig {
    @Autowired
    private DataSourceConfig dataSourceConfig;

    @Bean(name = "manageSessionBean")
    public SqlSessionFactoryBean sqlSessionFactoryBean() throws IOException{
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSourceConfig.manageDataSource());
        Configuration configuration = new Configuration();
        // 扫描对应的mapper文件
        factoryBean.setMapperLocations(new Resource[]{new ClassPathResource("UserMapper.xml")});
        factoryBean.setConfiguration(configuration);
        return factoryBean;
    }
}

本问题引自：https://blog.csdn.net/lmy86263/article/details/53428417

2、Resource注解和Autowired注解有什么区别，请列举以下适用地

@Resource和@Autowired都是做bean的注入时使用，其实@Resource并不是Spring的注解，它的包是javax.annotation.Resource，需要导入，但是Spring支持该注解的注入。

@Autowired为Spring提供的注解，需要导入包org.springframework.beans.factory.annotation.Autowired;只按照byType注入。

@Autowired注解是按照类型（byType）装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它的required属性为false。如果我们想使用按照名称（byName）来装配，可以结合@Qualifier注解一起使用。(通过类型匹配找到多个candidate,在没有@Qualifier、@Primary注解的情况下，会使用对象名作为最后的fallback匹配)如下：



public class TestServiceImpl {
    @Autowired
    @Qualifier("userDao")
    private UserDao userDao; 
}

@Resource默认按照ByName自动注入，由J2EE提供，需要导入包javax.annotation.Resource。@Resource有两个重要的属性：name和type，而Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以，如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不制定name也不制定type属性，这时将通过反射机制使用byName自动注入策略。

@Resource装配顺序：

①如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常。

②如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常。

③如果指定了type，则从上下文中找到类似匹配的唯一bean进行装配，找不到或是找到多个，都会抛出异常。

④如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配。

@Resource的作用相当于@Autowired，只不过@Autowired按照byType自动注入。

3、在springboot中如何启用filter，如何设置filter的启动次序

第一种 @WebFilter + @ServletComponentScan 注解

1、首先自定义过滤器

如下自定义过滤器 ReqResFilter 必须实现 javax.servlet.Filter。

然后添加注解 @WebFilter（javax.servlet.annotation.WebFilter），urlPatterns 过滤器要过滤的URL规则配置，filterName 过滤器的名称。

package com.wenbei.filter;

import lombok.extern.slf4j.Slf4j;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

//@Order(1)
@Slf4j
@WebFilter(urlPatterns = "/*", filterName = "reqResFilter")
public class ReqResFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) 
            throws IOException, ServletException {
        log.info("=============自定义过滤器============");
        filterChain.doFilter(servletRequest,servletResponse);
    }

    @Override
    public void destroy() {

    }
}

2、添加 @ServletComponentScan 注解

然后在启动类上加一个注解 @ServletComponentScan 就可以了，然后启动springboot 访问你的接口就会看到打印过滤器里的内容了。

这种方式下想定义Filter的顺序，就必须限定 Filter 的类名，比如刚才那个 Filter 叫 ReqResFilter ，加入我们现在新写了一个 Filter 叫 AlibabaFilter ，那么顺序就是 AlibabaFilter > ReqResFilter 。

所以这种方式虽然实现起来简单，只需要注解，但自定义顺序就必须要限定类名，使用类名达到排序效果了。

第二种自定义配置类配置过滤器

1、单个过滤器时

1、自定义配置类加载自定义过滤器 ReqResFilter

还是刚才那个自定义过滤器，只不过上面的两个注解都可以去掉了。

@Configuration
public class WebConfig {
    @Bean
    public FilterRegistrationBean reqResFilter() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        ReqResFilter reqResFilter = new ReqResFilter();
        filterRegistrationBean.setFilter(reqResFilter);　　　　 filterRegistrationBean.addUrlPatterns("*.json");//配置过滤规则 　　　　 return filterRegistrationBean;
　　} }

2、确保 WebConfig 类能被扫描到就可以了，然后启动springboot 访问你的接口就会看到打印过滤器里的内容了。

2、多个过滤器时如何配置

多个过滤器，怎么配置，都写在一个 FilterRegistrationBean 里吗？配置执行顺序怎么配置？过滤器名称怎么配置

新增一个过滤器

如下，新增一个过滤器 ReqResFilter1

public class ReqResFilter1 implements Filter {
    private static Logger logger = LoggerFactory.getLogger(ReqResFilter1.class);

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        //获取 filterRegistrationBean.addInitParameter("name","hahahhhaa")设置的参数
        System.out.println("init=============="+filterConfig.getInitParameter("name"));
    }
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("2222222222222222222222222222");
        filterChain.doFilter(servletRequest,servletResponse);
    }

    @Override
    public void destroy() {
    }
}

修改配置类

现在我们有两个过滤器 ReqResFilter 和 ReqResFilter1 ，怎么设置执行顺序。请看下面的代码。

这里我们， WebConfig 类里再写一个 reqResFilter1 方法注册新增的这个过滤器。和刚才不同的是我们指定了多个过滤器的 Order 即执行顺序，ReqResFilter1 的 Order 为2，设置 ReqResFilter 的Order为1。

@Configuration
public class WebConfig {

    @Bean
    public FilterRegistrationBean reqResFilter1() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();

        ReqResFilter1 reqResFilter1 = new ReqResFilter1();

        filterRegistrationBean.setFilter(reqResFilter1);
        filterRegistrationBean.addUrlPatterns("*.json");//配置过滤规则
        filterRegistrationBean.addInitParameter("name","hahahhhaa");//设置init参数
        filterRegistrationBean.setName("reqResFilter1");//设置过滤器名称
        filterRegistrationBean.setOrder(2);//执行次序

        return filterRegistrationBean;
    }

    @Bean
    public FilterRegistrationBean reqResFilter() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();

        ReqResFilter reqResFilter = new ReqResFilter();

        filterRegistrationBean.setFilter(reqResFilter);

        //配置多个过滤规则
//        List<String> urls = new ArrayList<>();
//        urls.add("/order/*");
//        urls.add("/user/*");
//        filterRegistrationBean.setUrlPatterns(urls);

        filterRegistrationBean.addUrlPatterns("*.json");//配置过滤规则
        filterRegistrationBean.setName("reqResFilter");//设置过滤器名称
        filterRegistrationBean.setOrder(1);//执行次序

        return filterRegistrationBean;
    }
}

另外 filterRegistrationBean.addInitParameter("name","hahahhhaa");//设置init参数设置的参数在 Filter 的init 方法里的 FilterConfig 对象里可以获取到，即 filterConfig.getInitParameter("name")

另外 filterRegistrationBean.setUrlPatterns(urls); 可以设置多个URL匹配规则，setUrlPatterns接收一个List<String>类型的参数

当不设置 setOrder 次序时，过滤器的执行顺序默认是 Bean 的加载顺序。在当前 WebConfig 类中，先加载的是 reqResFilter1方法即 ReqResFilter1 过滤器，后加载的是 reqResFilter 方法即 ReqResFilter 过滤器。

4、在springboot中如何加载多环境下的对应多个配置文件（yml或properties）

1、首先在resource目录下建立application-logger.yml文件。此处文件的命名需要满足下方条件。按照application-xxx.yml这种形式来。

在原有的application.properties文件中加入下方代码：

spring.profiles.active=logger

这边需要修改pom.xml来实现切换配置文件，引入如下：

1. 配置profiles节点

<!-- 多环境配置方案 -->
  <profiles>
    <profile>
      <!-- 本地开发环境 -->
      <id>dev</id>
      <properties>
        <profileActive>dev</profileActive>
      </properties>
      <!-- 默认开启这个配置 -->
      <activation>
        <activeByDefault>true</activeByDefault>
      </activation>
    </profile>
    <profile>
      <id>pprod</id>
      <properties>
        <profileActive>pprod</profileActive>
      </properties>
    </profile>
    <profile>
      <id>uat</id>
      <properties>
        <profileActive>uat</profileActive>
      </properties>
    </profile>
    <profile>
      <id>prod</id>
      <properties>
        <profileActive>prod</profileActive>
      </properties>
    </profile>
  </profiles>

2. 开启过滤，用指定的参数替换directory下的文件中的参数，这是在< build >下的

<resources>
      <resource>
        <!--开启过滤，用指定的参数替换directory下的文件中的参数-->
        <directory>src/main/resources</directory>
        <filtering>true</filtering>
      </resource>
    </resources>

3.添加解析插件

	<plugin>
           <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-resources-plugin</artifactId>
            <configuration>
                <delimiters>@</delimiters>
                <useDefaultDelimiters>false</useDefaultDelimiters>
            </configuration>
        </plugin>

4.修改application.yml文件，@profileActive@ 中的数据对应的是你properties的数据

  profiles:
    active: @profileActive@

5.需要添加yaml的依赖

	<dependency>
	            <groupId>org.yaml</groupId>
	            <artifactId>snakeyaml</artifactId>
	</dependency>

用命令clean package -P prod 进行打包

5.如何配置数据库连接池，连接池参数分别代表什么含义

SpringBoot+Druid+Log4j2配置总结：https://blog.csdn.net/qq_36370294/article/details/81535532

1.配置pom.xml

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.3.RELEASE</version>
    <relativePath/>
</parent>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.10</version>
</dependency>
<!--日志-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

二、配置application.yml，Druid连接池的相关配置

spring:
  datasource:
      type: com.alibaba.druid.pool.DruidDataSource
      druid:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://192.168.123.180:3306/test?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&failOverReadOnly=false
        username: root
        password: root
        # 配置初始化大小、最小、最大
        initial-size: 20
        min-idle: 1
        max-active: 50
        #配置获取连接等待超时的时间
        max-wait: 60000
        #配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
        time-between-eviction-runs-millis: 60000
        #配置一个连接在池中最小生存的时间，单位是毫秒
        min-evictable-idle-time-millis: 300000
        #测试连接
        validation-query: SELECT 'x'
        #申请连接的时候检测，建议配置为true，不影响性能，并且保证安全性
        test-while-idle: true
        #获取连接时执行检测，建议关闭，影响性能
        test-on-borrow: false
        #归还连接时执行检测，建议关闭，影响性能
        test-on-return: false
        #是否开启PSCache，PSCache对支持游标的数据库性能提升巨大，oracle建议开启，mysql下建议关闭
        pool-prepared-statements: false
        #开启poolPreparedStatements后生效
        max-pool-prepared-statement-per-connection-size: 20
        #配置扩展插件，常用的插件有=>stat:监控统计  log4j:日志  wall:防御sql注入
        filters: stat,wall,log4j2
        # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
        connection-properties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
        # Druid WebStatFilter配置
        web-stat-filter:
          enabled: true
          url-pattern: /*
          exclusions: '*.gif,*.png,*.jpg,*.html,*.js,*.css,*.ico,/druid/*'
        # Druid StatViewServlet配置
        stat-view-servlet:
          enabled: true
          url-pattern: /druid/*
          reset-enable: true
          login-username: admin
          login-password: admin
        # 配置日志输出
        filter:
          slf4j:
            enabled: true
            statement-create-after-log-enabled: false
            statement-close-after-log-enabled: false
            result-set-open-after-log-enabled: false
            result-set-close-after-log-enabled: false
logging:
  config: classpath:log4j2.xml

2. 采用yml配置，log4j2.yml

修改pom.xml

<!-- 加上这个才能辨认到log4j2.yml文件 -->
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-yaml</artifactId>
        </dependency>

添加：log4j2.yml

Configuration:
  status: OFF
  name: YAMLConfigTest
  properties:
    property:
      name: filename
      value: target/test-yaml.log
  thresholdFilter:
    level: debug
  appenders:
    #只接受程序中DEBUG级别的日志进行处理
    Console:
      name: Console
      target: SYSTEM_OUT
      ThresholdFilter:
        level: DEBUG
        onMatch: ACCEPT
        onMismatch: DENY
      PatternLayout:
        Pattern: "[%d{HH:mm:ss.SSS}] %-5level %class{36} %L %M - %msg%xEx%n"
    #处理DEBUG级别的日志，并把该日志放到logs/debug.log文件中
    RollingFile:
      #打印出DEBUG级别日志，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档
      -
        name: RollingFileDebug
        fileName: ./logs/debug.log
        filePattern: "logs/$${date:yyyy-MM}/debug-%d{yyyy-MM-dd}-%i.log.gz"
        PatternLayout:
          Pattern: "[%d{yyyy-MM-dd HH:mm:ss}] %-5level %class{36} %L %M - %msg%xEx%n"
        Filters:
          ThresholdFilter:
            -
              level: DEBUG
            -
              level: INFO
              onMatch: DENY
              onMismatch: NEUTRAL
        Policies:
          SizeBasedTriggeringPolicy:
            size: 512MB
      #处理INFO级别的日志，并把该日志放到logs/info.log文件中
      -
        name: RollingFileInfo
        fileName: ./logs/info.log
        filePattern: "logs/$${date:yyyy-MM}/info-%d{yyyy-MM-dd}-%i.log.gz"
        PatternLayout:
          Pattern: "[%d{yyyy-MM-dd HH:mm:ss}] %-5level %class{36} %L %M - %msg%xEx%n"
        Filters:
          #只接受INFO级别的日志，其余的全部拒绝处理
          ThresholdFilter:
            -
              level: INFO
            -
              level: WARN
              onMatch: DENY
              onMismatch: NEUTRAL
        Policies:
          SizeBasedTriggeringPolicy:
            size: 512MB
      #处理WARN级别的日志，并把该日志放到logs/warn.log文件中
      -
        name: RollingFileWarn
        fileName: ./logs/warn.log
        filePattern: "logs/$${date:yyyy-MM}/warn-%d{yyyy-MM-dd}-%i.log.gz"
        PatternLayout:
          Pattern: "[%d{yyyy-MM-dd HH:mm:ss}] %-5level %class{36} %L %M - %msg%xEx%n"
        Filters:
          ThresholdFilter:
            -
              level: WARN
            -
              level: ERROR
              onMatch: DENY
              onMismatch: NEUTRAL
        Policies:
          SizeBasedTriggeringPolicy:
            size: 512MB
      #处理error级别的日志，并把该日志放到logs/error.log文件中
      -
        name: RollingFileError
        fileName: ./logs/error.log
        filePattern: "logs/$${date:yyyy-MM}/error-%d{yyyy-MM-dd}-%i.log.gz"
        PatternLayout:
          Pattern: "[%d{yyyy-MM-dd HH:mm:ss}] %-5level %class{36} %L %M - %msg%xEx%n"
        ThresholdFilter:
          level: ERROR
        Policies:
          SizeBasedTriggeringPolicy:
            size: 512MB
      #druid的日志记录追加器
      -
        name: druidSqlRollingFile
        fileName: ./logs/druid-sql.log
        filePattern: "logs/$${date:yyyy-MM}/api-%d{yyyy-MM-dd}-%i.log.gz"
        PatternLayout:
          Pattern: "[%d{yyyy-MM-dd HH:mm:ss}] %-5level %L %M - %msg%xEx%n"
        Policies:
          SizeBasedTriggeringPolicy:
            size: 512MB
  loggers:
    logger:
      #记录druid-sql的记录
      name: druid.sql.Statement
      level: debug
      additivity: false
      appender-ref:
        ref: druidSqlRollingFile
    #log4j2 自带过滤日志
    Logger:
      -
        name: org.apache.catalina.startup.DigesterFactory
        level: error
      -
        name: org.apache.catalina.util.LifecycleBase
        level: error
      -
        name: org.apache.coyote.http11.Http11NioProtocol
        level: warn
      -
        name: org.apache.sshd.common.util.SecurityUtils
        level: warn
      -
        name: org.apache.tomcat.util.net.NioSelectorPool
        level: warn
      -
        name: org.crsh.plugin
        level: warn
      -
        name: org.crsh.ssh
        level: warn
      -
        name: org.eclipse.jetty.util.component.AbstractLifeCycle
        level: error
      -
        name: org.hibernate.validator.internal.util.Version
        level: warn
      -
        name: org.springframework.boot.actuate.autoconfigure.CrshAutoConfiguration
        level: warn
      -
        name: org.springframework.boot.actuate.endpoint.jmx
        level: warn
      -
        name: org.thymeleaf
        level: warn
    root:
      level: DEBUG
      appender-ref:
        -
          ref: Console
        -
          ref: RollingFileInfo
        -
          ref: RollingFileWarn
        -
          ref: RollingFileError
        -
          ref: RollingFileDebug

6.如何配置redis连接池，连接池参数分别代表什么含义

xml配置

<!-- 定义加载资源文件 -->
<context:property-placeholder location="classpath:redis.properties" ignore-unresolvable="true" />
 
 
<!-- 对象资源池初始化配置  -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    <property name="maxTotal" value="${redis.pool.maxTotal}"/>
	<property name="maxIdle" value="${redis.pool.maxIdle}" />
	<property name="minIdle" value="${redis.pool.minIdle}"/>
	<property name="maxWaitMillis" value="${redis.pool.maxWaitMillis}"/>
	<property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
	<property name="testOnReturn" value="${redis.pool.testOnReturn}" />
	<property name="testWhileIdle" value="${redis.pool.testWhileIdle}" />
	<property name="numTestsPerEvictionRun" value="${redis.pool.numTestsPerEvictionRun}" />
	<property name="timeBetweenEvictionRunsMillis" value="${redis.pool.timeBetweenEvictionRunsMillis}" />
</bean>
	
<!-- redis 单机资源池 -->
<bean id="jedisPool" class="redis.clients.jedis.JedisPool" scope="singleton"  lazy-init="true" >
    <constructor-arg  index="0"  ref="jedisPoolConfig" />  
    <constructor-arg  index="1"  value="${redis.ip}" />  
    <constructor-arg  index="2"  value="${redis.port}" type="int" />
    <constructor-arg  index="3"  value="${redis.timeout}" type="int" />
</bean>

properties配置

#最大活动对象数     
redis.pool.maxTotal=1000    
#最大能够保持idel状态的对象数      
redis.pool.maxIdle=100  
#最小能够保持idel状态的对象数   
redis.pool.minIdle=50    
#当池内没有返回对象时，最大等待时间    
redis.pool.maxWaitMillis=10000    
#当调用borrow Object方法时，是否进行有效性检查    
redis.pool.testOnBorrow=true    
#当调用return Object方法时，是否进行有效性检查    
redis.pool.testOnReturn=true  
#“空闲链接”检测线程，检测的周期，毫秒数。如果为负值，表示不运行“检测线程”。默认为-1.  
redis.pool.timeBetweenEvictionRunsMillis=30000  
#向调用者输出“链接”对象时，是否检测它的空闲超时；  
redis.pool.testWhileIdle=true  
# 对于“空闲链接”检测线程而言，每次检测的链接资源的个数。默认为3.  
redis.pool.numTestsPerEvictionRun=50  
#redis服务器的IP    
redis.ip=xxxxxx  
#redis服务器的Port    
redis1.port=6379

或者通过工厂获取池子配置,然后set对应的值:

swagger配置：引自：https://www.cnblogs.com/interflow/p/11760322.html

Swagger作用：

自动生成javaAPI，避免开发过程中接口文档更新不及时。
Swagger 一.导入依赖：

导入依赖

<!--swagger包-->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.2.2</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.2.2</version>
</dependency>
<!--swagger包结束-->


 
Swagger 二.Swagger首页的配置：

创建一个SwaggerConfig类，通过@Configuration托管给spring，然后通过@EnableSwagger2 注解开启Swagger，Config类大部分都是固定的，没什么改变的需要：

代码：

package com.zy100.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 * @author 赵振宇
 * @date 2019/10/29 0029
 * @time 14:51
 * @desc Swagger配置类，该类里面的应该是固定的，主要用来设置文档的主题信息，比如文档的大标题，副标题，公司名
 * 等
 */
@Configuration//托管spring
@EnableSwagger2//开启swagger功能
public class SwaggerConfig {
    /**
     * 创建API应用
     * apiInfo() 增加API相关信息
     * 通过select()函数返回一个ApiSelectorBuilder实例,用来控制哪些接口暴露给Swagger来展现，
     * 本例采用指定扫描的包路径来定义指定要建立API的目录。
     *
     * @return
     */
    @Bean
    public Docket createRestApi(){
        //版本类型是swagger2
        return new Docket(DocumentationType.SWAGGER_2)
                //通过调用自定义方法apiInfo，获得文档的主要信息
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.zy100.controller"))//扫描该包下面的API注解
                .paths(PathSelectors.any())
                .build();
    }
    /**
     * 创建该API的基本信息（这些基本信息会展现在文档页面中）
     * 访问地址：http://项目实际地址/swagger-ui.html
     * @return
     */
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("使用Swagger2 构建RESTful APIS - zy") //接口管理文档首页显示
                .description("zy - Swagger使用演示")//API的描述
                .termsOfServiceUrl("www.footmark.top")//网站url等
                .version("1.0")
                .build();
    }
}

 
Swagger 三.Swagger的Controller示例

在需要生成接口文档的Controller中加上@API注解，类中需要生成接口的方法上加上@ApiOperation注解：

代码：

package com.zy100.controller;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;

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

/**
 * @author 赵振宇
 * @date 2019/10/29 0029
 * @time 15:00
 * @desc 配合swagger创建一个Controller，演示方便不再创建service层
 */
@RestController
@Api("用户模块API文档")//注解api说明该类需要生成api文档
public class UserController {
    /**
     * 该类中
     * @param map 类似于一个user对象
     * key就是对象的属性
     * value就是对象的属性值
     *   ------------------------
     * 属性 id name birthday
     * @return
     *
     */
    //正常业务整添加是对象，前台传JSON对象，在此使用map代替
    @PostMapping("/user")//如果使用swagger自动生成接口文档，一定要加上请求类型，不然会导致swagger把所有请求都会生成一下
    @ApiOperation("添加用户")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "map",//参数名字
                    value = "这是一个添加的对象",//参数的描述
                    required = true,//是否必须传参数，true是
                    paramType = "body")//参数类型 body代表json
    })
    public Map add(@RequestBody Map map){
        return map;
    }
    //根据id删除数据。
    @DeleteMapping("/user/{id}")
    @ApiOperation("删除用户")//API中说明的该类的作用
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id",//参数名字
                    value = "用户id",//参数的描述
                    required = true,//是否必须传参数，true是
                    paramType = "path",//参数类型 path代表路径参数
                    dataType = "int")//参数类型 int
    })
    public String deltete(@PathVariable int id){
        return "{code:200,msg:删除"+id+"成功}";
    }
    //根据传入的对象信息进行更新
    @PutMapping("/user")
    @ApiOperation("更新用户")//API中说明的该类的作用
    @ApiImplicitParams({
            @ApiImplicitParam(name = "map",//参数名字
                    value = "更新的用户",//参数的描述
                    required = true,//是否必须传参数，true是
                    paramType = "body",//参数类型 body
                    dataType = "map")//参数类型 int
    })
    public Map update(@RequestBody Map map){
        return map;
    }
    @GetMapping("/user/{id}")
    @ApiOperation("查询永不用户")//API中说明的该类的作用
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id",//参数名字
                    value = "查询的用户id",//参数的描述
                    required = true,//是否必须传参数，true是
                    paramType = "path",//参数类型 body
                    dataType = "int")//参数类型 int
    })
    public Map getOne(@PathVariable int id){
        Map<String,Object> map = new HashMap<>();
        map.put("id",id);
        map.put("name","张三");
        map.put("birthday",new Date());
        return map;
    }
}

swagger主要涉及：

@Api

@ApiOperation

当时的那个女孩

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java面试问题整理

1、mapper接口类和mybatis实体配置xml之间有哪些对应关系1.2 在使用mybatis的时候，我们只需要编写Dao层的mapper.java接口和mapper.xml文件。mybatis会根据UserMapper.xml中配置的信息创建一个实现了UserMaper.java接口的代理类(使用JDK动态代理); 因此在配置UserMapper.xml时会要求:在UserMapper.xml中namespace等于UserMapper.java接口地址(即UserMapper的全限定名)
复制链接

扫一扫