Spring知识总结

目录

知识复习

一.spring

1.概念

2.常用注解

3.@componentsacn

4.aop

二.mybatis-plus

概念：

1.常见配置yaml

2.设置雪花主键

3.分页配置

4.代码生成器

5.公共字段自动填充

6.Lambda查询

三.Mybatis

概念：

1.xmlMapper文件

2.动态sql

3.自定义返回类型

4.mybatis-config.xml核心配置文件

5.单独使用的示例

6.在spring中的使用

8.事务的使用

9.整合druid连接池

10.整合druid在配置类中配置

四.springmvc

概念：

1.springmvc的在javaweb中的单独使用

2.springmvc在spring中的使用

3.springmvc的参数日期格式转换

4.全局日期参数自动转换

5.拦截器

6.拦截器的路径配置

7.拦截器和过滤器的区别

8.跨域配置

9.放行静态资源

五.springboot

概念：

1.springboot的搭建

2.springboot中开发web项目的依赖

（1）.引入springmvc依赖

（2）.引入mysql连接依赖**

（3）引入druid启动依赖

（4）.引入mybatis-plus依赖**

（5）.引入lombok依赖

3.对以上依赖的相关配置

(1)对端口配置

(2).对mysql和druid连接池配置

(3)对mybatis-plus的配置

4.springboot的简单示例

5.分页查询示例

6.LambdQueryWrapper

7.springboot中配置跨域

---

知识复习

一.spring

1.概念

Spring框架中的核心模块是IoC（Inversion of Control ，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）。

1. IoC（控制反转）：IoC是Spring框架的核心特性之一，通过使用依赖注入，将对象的创建和依赖关系管理的责任从应用程序代码中解耦。通过IoC容器，我们可以将对象的创建和组装交由Spring框架来负责，使应用程序更加灵活、可测试和可维护。

2. AOP（面向切面编程）：AOP是Spring框架的另一个核心特性，它通过将与业务逻辑无关的横切关注点（如日志、安全性、事务管理）从业务逻辑中分离出来，实现了关注点的模块化。通过使用AOP，我们可以通过声明方式将这些横切关注点应用到我们的应用程序中，而不需要修改业务逻辑代码。

2.常用注解

1. @Configuration: 标记一个类为配置类，用于替代XML配置文件。

   示例：

   @Configuration
   public class AppConfig {
       // 配置Bean的方法
   }

2. @Bean: 标记一个方法产生一个Bean对象，并由Spring容器进行管理。

   示例：

   @Configuration
   public class AppConfig {
       @Bean
       public UserService userService() {
           return new UserService();
       }
   }

3. @Scope: 定义Bean的作用范围，默认为单例。

   示例：

   @Component
   @Scope("prototype")
   public class UserService {
       // 类的具体实现
   }

4. @Value: 注入一个值到Bean中，可以是基本类型、字符串、引用等。

   示例：

   @Component
   public class UserService {
       @Value("John Doe")
       private String userName;
       
       // 其他方法
   }

5. @Qualifier: 当存在多个相同类型的Bean时，通过该注解指定注入的Bean。

   示例：

   @Autowired
   @Qualifier("userRepository")
   private UserRepository userRepository;

6. @PostConstruct: 在Bean实例化后执行初始化方法。

   示例：

   @Component
   public class UserService {
       @PostConstruct
       public void init() {
           // 初始化逻辑
       }
   }

7. @PreDestroy: 在Bean销毁前执行清理操作。

   示例：

   @Component
   public class UserService {
       @PreDestroy
       public void cleanup() {
           // 清理逻辑
       }
   }

8.@component注解

@Component是Spring中最常用的注解之一，用于标记一个类为组件类，并由Spring容器进行管理。

它的派生注解有以下几种：

1. @Controller: 标记一个类为控制器（Web MVC）。

   示例：

   @Controller
   public class UserController {
       // 控制器的具体实现
   }

2. @Service: 标记一个类为服务类，通常用于业务逻辑的处理。

   示例：

   @Service
   public class UserService {
       // 服务类的具体实现
   }

3. @Repository: 标记一个类为存储库类，用于数据持久化。

   示例：

   @Repository
   public class UserRepository {
       // 存储库类的具体实现
   }

3.@componentsacn

@ComponentScan是一个Spring框架提供的注解，用于指定要扫描的包路径，将被@Component、@Controller、@Service、@Repository等注解标注的类注册为Spring容器中的Bean。通过@ComponentScan注解，可以自动扫描并注册指定包路径下的所有符合条件的组件。

@ComponentScan注解通常用在Spring配置类上，作为配置类的注解之一。通过在配置类上添加@ComponentScan注解并指定要扫描的包路径，Spring容器会自动扫描并注册指定包路径下的所有组件。

例如：

@Configuration
@ComponentScan("com.example.demo")
public class AppConfig {
    //其他配置信息
}

上述代码中，使用@ComponentScan注解指定要扫描的包路径为"com.example.demo"，Spring容器会自动扫描并注册该包路径下的所有组件，包括被@Component、@Controller、@Service、@Repository等注解标注的类。

需要注意的是，@ComponentScan注解还可以通过其属性basePackages和value来指定多个包路径进行扫描，以及通过excludeFilters和includeFilters属性来指定过滤条件进行筛选注册的组件。

4.aop

在Spring中使用AOP，不使用XML配置和Spring Boot。可以按照以下步骤进行配置：

1. 创建一个切面类，使用@Aspect注解标注，并添加@Component注解使其成为Spring的组件：

@Aspect
@Component
public class LoggingAspect {
​
    @Before("execution(* com.example.demo.service.*.*(..))")
    public void beforeMethodCall(JoinPoint joinPoint) {
        // 在方法调用前执行的逻辑
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Before method call: " + methodName);
    }
​
    // 其他通知方法...
}

1. 创建一个配置类，使用@Configuration注解标注，并添加@ComponentScan注解指定要扫描的包路径：

@Configuration
@ComponentScan(basePackages = "com.example.demo")
public class AppConfig {
​
}

1. 在Spring应用上下文中加载配置类并启动：

public class Main {
​
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
​
        // 获取切面类作为bean并使用
        LoggingAspect loggingAspect = context.getBean(LoggingAspect.class);
​
        // 调用业务方法
        SomeService someService = context.getBean(SomeService.class);
        someService.doSomething();
​
        context.close();
    }
}

通过以上配置，可以实现在Spring中使用AOP，切面类中定义的通知方法将在相应的切点被触发时执行 逻辑。

注意：在配置类中使用@ComponentScan注解指定要扫描的包路径，以确保Spring能够扫描到切面类作为组件进行注册和使用

二.mybatis-plus

概念：

MyBatis-Plus是基于MyBatis的增强工具，提供了更方便、更强大的功能来简化数据库访问的开发。

以下是MyBatis-Plus的一些主要概念：

1. 实体（Entity）：在MyBatis-Plus中，实体是与数据库中的表相映射的Java对象。实体类通常包含表中的字段对应的属性，并使用注解来指定与数据库表的映射关系。

2. Mapper：Mapper是用于执行具体SQL操作的接口。使用MyBatis-Plus时，可以通过继承BaseMapper接口来轻松地实现常见的CRUD操作，也可以自定义SQL语句。

3. Service：Service是用于封装业务逻辑的组件。MyBatis-Plus提供了BaseService接口，可以用于快速创建Service类，也提供了常用的查询、更新等方法。

4. Wrapper：Wrapper是用于创建查询条件的封装类。MyBatis-Plus中的Wrapper接口提供了一系列的方法，可以根据具体需求灵活地构建查询条件，如eq、like、gt等方法。

5. 自动填充（MetaObjectHandler）：MyBatis-Plus提供了自动填充功能，可以在插入和更新实体时自动填充额外的字段，如创建时间、更新时间等。可以通过实现MetaObjectHandler接口来自定义填充的逻辑。

6. 分页支持：MyBatis-Plus提供了方便的分页查询功能，可以通过Page对象进行分页查询，并提供了一系列的Pageable方法进行分页参数的设置。

7. 主键策略：MyBatis-Plus支持多种主键策略，如自增、UUID、雪花算法等。可以通过注解@TableId来指定主键字段，并使用@KeySequence注解来配置主键生成策略。

通过使用MyBatis-Plus，可以简化数据库访问的开发，提高开发效率，并提供了更多的功能和扩展点，使得开发工作更加便捷。

1.常见配置yaml

以下是一个示例的 MyBatis-Plus 的 yaml 配置文件：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/testdb?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
​
mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
​
  # 分页配置
  pagehelper:
    helper-dialect: mysql
    reasonable: true
    support-methods-arguments: true
    params: count=countSql
​
  # 逻辑删除配置
  global-config:
    db-config:
      logic-delete-field: is_deleted
      logic-delete-value: 1
      logic-not-delete-value: 0
​
  # 主键策略配置
  global-config:
    db-config:
      id-type: auto

2.设置雪花主键

要在 MyBatis-Plus 中使用注解方式设置雪花主键生成器，可以按照以下步骤进行设置：

1. 1在实体类中使用 @TableId 注解标注主键字段，并设置主键生成策略为 IdType.ASSIGN_ID，同时指定一个自定义的主键生成器。

@Data
@TableName("your_table")
public class YourEntity {
    @TableId(value = "id", type = IdType.ASSIGN_ID, generator = "snowflake")
    private Long id;
    
    // 其他字段...
}

1. 2创建一个自定义的主键生成器类，实现 IdentifierGenerator 接口，并重写 nextId 方法来生成雪花算法的主键。

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.core.incrementer.IdentifierGenerator;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
​
public class SnowflakeGenerator implements IdentifierGenerator {
    @Override
    public Number nextId(Object entity) {
        return IdWorker.getId();
    }
​
    @Override
    public String nextUUID(Object entity) {
        return IdWorker.get32UUID();
    }
​
    @Override
    public Object nextId(Object entity, String fieldName) {
        return IdWorker.getId();
    }
}

1. 3启动类或配置类中使用 @Bean 注解来注册自定义的主键生成器。

@Configuration
public class MybatisPlusConfig {
    @Bean
    public IdentifierGenerator snowflake() {
        return new SnowflakeGenerator();
    }
}

通过以上设置，在使用 MyBatis-Plus 进行插入操作时，会自动调用雪花主键生成器生成全局唯一的 ID 作为主键值，并将其赋给实体类中的 id 字段

3.分页配置

要在 MyBatis-Plus 中使用分页插件，可以按照以下步骤进行设置：

1. 添加依赖：在项目的 POM 文件中添加 MyBatis-Plus 分页插件的依赖。

    com.baomidou
    mybatis-plus-boot-starter
    {version}

1. 配置分页插件：在启动类或配置类中添加 PaginationInterceptor 的 Bean，来启用分页插件。

@Configuration
public class MybatisPlusConfig {
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

1. 使用分页查询：在需要分页查询的方法中使用 Page 类进行分页操作。

@Service
public class YourService {
    @Autowired
    private YourMapper yourMapper;
    
    public IPage getPageData(Integer pageNum, Integer pageSize) {
        // 创建分页对象
        Page page = new Page<>(pageNum, pageSize);
        
        // 执行分页查询，结果会自动封装在 page 对象中
        IPage pageData = yourMapper.selectPage(page, null);
        
        return pageData;
    }
}

1. 获取分页结果：通过分页对象的方法可以获取到分页的相关信息和查询结果。

IPage pageData = yourService.getPageData(1, 10);
​
long total = pageData.getTotal(); // 获取总记录数
List records = pageData.getRecords(); // 获取当前页的记录列表
​
// 分页信息
long current = pageData.getCurrent(); // 当前页码
long pages = pageData.getPages(); // 总页数
long size = pageData.getSize(); // 每页记录数
boolean hasPrevious = pageData.hasPrevious(); // 是否有前一页
boolean hasNext = pageData.hasNext(); // 是否有下一页

4.代码生成器

下面是一个使用 MyBatis-Plus 代码生成器生成代码的示例，不使用 XML 配置文件，并且每行都有注释说明：

1.依赖

    com.baomidou
    mybatis-plus-generator
    {version}

2.示例

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import org.apache.ibatis.type.JdbcType;
​
public class Generator {
    public static void main(String[] args) {
        // 数据源配置
        DataSourceConfig dataSourceConfig = new DataSourceConfig.Builder("jdbc:mysql://localhost:3306/db_name", "root", "root")
                .driver(DbType.MYSQL.getDriver()) // 设置数据库类型
                .type(DbType.MYSQL) // 设置数据库类型
                .build();
​
        // 全局配置
        GlobalConfig globalConfig = new GlobalConfig.Builder()
                .outputDir(System.getProperty("user.dir") + "/src/main/java") // 设置输出目录
                .author("Your Name") // 设置作者
                .openDir(true) // 生成完成后是否打开输出目录
                .dateType(DateType.ONLY_DATE) // 设置日期类型
                .idType(IdType.AUTO) // 设置主键类型
                .fileOverride(true) // 是否覆盖已有文件
                .build();
​
        // 包名配置
        PackageConfig packageConfig = new PackageConfig.Builder()
                .parent("com.example") // 设置父包名
                .moduleName("demo") // 设置模块名
                .entity("entity") // 设置实体类包名
                .mapper("mapper") // 设置Mapper接口包名
                .service("service") // 设置Service类包名
                .controller("controller") // 设置Controller类包名
                .build();
​
        // 策略配置
        StrategyConfig strategyConfig = new StrategyConfig.Builder()
                .naming(NamingStrategy.underline_to_camel) // 数据库表映射到实体的命名策略，下划线转驼峰命名
                .columnNaming(NamingStrategy.underline_to_camel) // 数据库表字段映射到实体类属性的命名策略，下划线转驼峰命名
                .entityTableFieldAnnotationEnable(true) // 是否生成实体类字段注解
                .entityLombokModel(true) // 是否使用Lombok注解
                .controllerRestStyle(true) // 是否生成@RestController风格控制器
                .controllerMappingHyphenStyle(true) // 是否驼峰转连字符
                .build();
​
        // 代码生成器
        AutoGenerator generator = new AutoGenerator(dataSourceConfig)
                .global(globalConfig)
                .packageInfo(packageConfig)
                .strategy(strategyConfig)
                .template(new TemplateConfig.Builder().build()); // 使用默认模板配置
​
        // 执行生成的代码
        generator.execute();
    }
}

5.公共字段自动填充

下面是一个使用 MyBatis-Plus 实现公共字段自动填充的示例：

首先，定义一个公共字段填充处理器：

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;
​
import java.time.LocalDateTime;
​
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
​
    @Override
    public void insertFill(MetaObject metaObject) {
        // 设置创建时间和更新时间字段的值为当前时间
        this.setFieldValByName("createTime", LocalDateTime.now(), metaObject);
        this.setFieldValByName("updateTime", LocalDateTime.now(), metaObject);
    }
​
    @Override
    public void updateFill(MetaObject metaObject) {
        // 设置更新时间字段的值为当前时间
        this.setFieldValByName("updateTime", LocalDateTime.now(), metaObject);
    }
}

然后，在实体类中添加对应的公共字段，并使用 @TableField 注解进行配置：

import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
​
import java.time.LocalDateTime;
​
@Data
@TableName("user")
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
​
    private String username;
​
    private String password;
​
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;
​
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updateTime;
}

最后，在启动类中将公共字段填充处理器添加到 MyBatis-Plus 的自动填充处理器列表中：

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.example.mapper")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

6.Lambda查询

MyBatis-Plus 提供了 Lambd 查询，通过使用 Lambda 表达式，可以更加简洁地进行条件查询。下面是一些常见的 Lambd 查询示例：

1. 等值查询：

// 使用 lambda 进行等值查询
List userList = userMapper.selectList(Wrappers.lambdaQuery().eq(User::getUsername, "admin"));

1. 模糊查询：

// 使用 lambda 进行模糊查询
List userList = userMapper.selectList(Wrappers.lambdaQuery().like(User::getUsername, "adm"));

1. 多条件查询：

// 使用 lambda 进行多条件查询
List userList = userMapper.selectList(Wrappers.lambdaQuery()
    .eq(User::getGender, "男")
    .like(User::getUsername, "adm")
    .lt(User::getAge, 30));

1. 自定义查询条件：

// 使用 lambda 自定义查询条件
List userList = userMapper.selectList(Wrappers.lambdaQuery()
    .eq(User::getGender, "男")
    .and(queryWrapper -> queryWrapper.like(User::getUsername, "adm").or().like(User::getEmail, "test")));
在以上示例中，User::getUsername、User::getGender 等方法引用代表了实体类的属性，可使用 lambda 表达式构建查询条件。

除了查询方法使用了 lambda 之外，还可以使用 UpdateWrapper 进行更新操作，示例代码如下：

// 使用 lambda 进行更新操作
userMapper.update(null, Wrappers.lambdaUpdate()
        .set(User::getUsername, "admin")
        .eq(User::getId, 1));

以上示例演示了一些常见的 Lambd 查询用法，使用 MyBatis-Plus 的 Lambd 查询可以大大简化查询条件的编写，提高开发效率。

三.Mybatis

概念：

MyBatis是一个开源的持久化框架，简化了数据库访问开发。它提供了一种将SQL语句与Java方法绑定的方式，使开发人员可以轻松地配置和执行数据库操作。

以下是MyBatis的一些关键概念：

1. Mapper XML：Mapper XML是配置SQL语句的地方。它包含了与数据库交互的具体SQL语句，以及SQL语句与Java方法之间的映射关系。

2. Mapper接口：Mapper接口定义了与数据库交互的方法。通过在接口方法上使用注解，可以将SQL语句绑定到方法上。

3. SqlSession：SqlSession是MyBatis与数据库交互的核心类。它提供了数据库操作的方法，如查询、插入、更新等。开发人员可以通过SqlSession执行Mapper接口中定义的方法。

4. ParameterHandler：ParameterHandler负责处理SQL语句的参数。它将Java对象转换为符合JDBC标准的参数，并将其传递给底层的JDBC驱动程序。

5. ResultSetHandler：ResultSetHandler负责处理查询结果。它将JDBC查询结果转换为Java对象，并将其返回给应用程序。

6. Executor：Executor负责执行SQL语句。它根据配置可以使用不同的执行策略，如简单、批处理或重用等。

1.xmlMapper文件

MyBatis 的 XML Mapper 文件是用来定义 SQL 映射关系以及提供 SQL 查询、插入、更新、删除等操作的地方。通常一个实体类对应一个 XML Mapper 文件，其命名规则是实体类名加上 Mapper.xml 后缀。

XML Mapper 文件的基本结构如下：

​

​
    
    
        SELECT * FROM user WHERE id = #{id}
    
​
    
    
        INSERT INTO user (username, password) VALUES (#{username}, #{password})
    
​
    
    
        UPDATE user SET username = #{username}, password = #{password} WHERE id = #{id}
    
​
    
    
        DELETE FROM user WHERE id = #{id}
    
​

2.动态sql

在 MyBatis 的 XML Mapper 文件中，可以使用动态 SQL 来根据条件生成不同的 SQL 语句。这样可以实现在同一个 SQL 查询中根据不同的条件进行灵活地拼接和生成不同的查询语句。

动态 SQL 主要通过以下几个标签来实现：

1. ：用于条件判断，根据给定的条件判断是否包含其中的 SQL 语句。

  SELECT * FROM user
  WHERE
    username = #{username}
    AND gender = #{gender}

在上面的例子中，如果传入的参数 username 和 gender 都不为空，那么最终生成的 SQL 语句将是 SELECT * FROM user WHERE username = #{username} AND gender = #{gender}。

1. 、、：用于条

   
     SELECT * FROM user
     
       WHERE id = #{id}
       WHERE username = #{username}
       WHERE gender = #{gender}
     
   

   件选择，根据给定的条件选择其中的一个分支执行。

在上面的例子中，根据传入的参数中的 id、username 和 gender 的值，选择不同的分支执行，生成不同的 SQL 语句。

1. ：用于循环处理，将一个集合中的元素逐个拼接到 SQL 语句中。

  DELETE FROM user
  WHERE id IN
  
    #{id}
  

5:用于条件处理

​

  SELECT * FROM user      AND username = #{username}    AND gender = #{gender}   

​

3.自定义返回类型

在 XML Mapper 文件中，可以使用 标签来定义自定义的结果映射。通过 标签，可以指定查询结果中的列和对象属性之间的映射关系，并定义如何处理结果。

以下是一个示例：

在以上示例中， 定义了一个名为 "userResultMap" 的结果映射，指定了 User 类型的结果。通过 标签可以指定列和对象属性之间的映射关系，通过 标签可以描述对象之间的关联关系。

然后，在相应的 SQL 查询语句中，可以使用 标签来引用定义好的结果映射：

  SELECT * FROM user WHERE id = #{id}

在以上示例中， 标签的 resultMap 属性指定了结果映射为 "userResultMap"。

4.mybatis-config.xml核心配置文件

当使用MyBatis进行数据库操作时，我们需要一个mybatis-config.xml文件来配置MyBatis的相关设置。下面是一个简单的mybatis-config.xml配置文件的示例：

  
  
​
  
  
    
      
      
​
      
      
        
        
        
        
        
      
    
  
​
  
  
    
  

在上面的示例中，配置文件的主要部分如下：

• 引入数据库连接信息：使用元素引入数据库连接信息配置文件（db.properties）。

• 设置MyBatis执行环境：使用和元素来设置MyBatis的执行环境。在示例中，我们只配置了一个名为"development"的环境，使用JDBC事务管理器和连接池来管理数据库连接。

• 注册Mapper接口：使用和元素来注册Mapper接口。在示例中，我们通过标签中的resource属性来指定Mapper接口对应的XML文件路径（com/example/mapper/UserMapper.xml）。

5.单独使用的示例

当在Java中使用MyBatis进行数据库操作时，需要进行以下步骤：

1. 导入MyBatis的相关依赖包。可以使用Maven或Gradle等构建工具来管理依赖。

2. 创建一个MyBatis的配置对象，通常通过解析mybatis-config.xml配置文件来创建。

3. 通过配置对象创建一个SqlSessionFactory，用于创建SqlSession。

4. 通过SqlSession进行数据库操作，包括查询、插入、更新、删除等。

下面是一个简单的示例演示如何使用MyBatis进行数据查询：

import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
​
public class MyBatisExample {
  public static void main(String[] args) {
    // 读取MyBatis配置文件
    try (InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml")) {
      // 创建MyBatis配置对象
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
​
      // 创建SqlSession
      try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
        // 执行查询操作
        List userList = sqlSession.selectList("com.example.mapper.UserMapper.getAllUsers");
​
        // 打印查询结果
        for (User user : userList) {
          System.out.println(user);
        }
      }
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

在上面的示例中，我们首先通过Resources.getResourceAsStream()方法加载mybatis-config.xml配置文件。然后使用SqlSessionFactoryBuilder类创建SqlSessionFactory对象来构建SqlSession。最后，使用SqlSession对象执行查询操作并打印结果。

6.在spring中的使用

在Spring中使用MyBatis，可以使用注解配置来整合它们。以下是使用注解配置的示例：

1. 导入MyBatis和Spring的相关依赖包。可以使用Maven或Gradle等构建工具来管理依赖。

2. 创建一个MyBatis的配置对象，并配置数据源。

3. 在Spring的配置类中，配置数据源和SqlSessionFactoryBean，并将MyBatis的配置对象注入到SqlSessionFactoryBean中。同时，使用MapperScan注解扫描Mapper接口所在的包。

4. 在需要使用数据库操作的地方，注入Mapper接口，通过调用Mapper接口的方法来进行数据库操作。

下面是一个简单的示例演示如何在Spring中使用MyBatis进行数据查询：

// UserMapper.java
@Mapper
public interface UserMapper {
  @Select("SELECT * FROM user")
  List getAllUsers();
}
​
// UserService.java
@Service
public class UserService {
  @Autowired
  private UserMapper userMapper;
​
  public List getAllUsers() {
    return userMapper.getAllUsers();
  }
}
​
// ApplicationConfig.java
@Configuration
@MapperScan("com.example.mapper")
public class ApplicationConfig {
  @Bean
  public DataSource dataSource() {
    DriverManagerDataSource dataSource = new DriverManagerDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://localhost:3306/mydatabase");
    dataSource.setUsername("root");
    dataSource.setPassword("password");
    return dataSource;
  }
​
  @Bean
  public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) throws Exception {
    SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
    sessionFactory.setDataSource(dataSource);
    return sessionFactory;
  }
}
​
// Main.java
public class Main {
  public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ApplicationConfig.class);
    UserService userService = context.getBean(UserService.class);
    List userList = userService.getAllUsers();
    for (User user : userList) {
      System.out.println(user);
    }
  }
}

在上面的示例中，我们使用了@Mapper注解标记了UserMapper接口，并使用@Select注解定义了查询方法。然后在UserService中注入了UserMapper接口，并在Main类中使用UserService来进行数据库操作。

在Spring的配置类ApplicationConfig中，我们使用@Configuration注解标记了配置类，并使用@MapperScan注解扫描了Mapper接口所在的包。

8.事务的使用

在MyBatis中使用事务，可以使用以下几种方式：

1. 编程式事务管理：

   • 在需要进行事务管理的方法上加上@Transactional注解，表示该方法需要在事务中执行。

   • 在方法内部通过SqlSessionFactory的openSession方法来获取一个SqlSession对象，并设置true来开启自动提交事务。

   • 在需要提交事务时，调用commit()方法来提交事务；发生异常时，调用rollback()方法来回滚事务。

2. 声明式事务管理：

   • 在Spring的配置文件中，配置一个事务管理器（例如使用DataSourceTransactionManager）。

   • 通过在需要进行事务管理的类或方法上加上@Transactional注解，表示该类或方法需要在事务中执行。

下面是一个简单的示例演示如何在MyBatis中使用编程式事务管理：

@Service
public class UserService {
  @Autowired
  private UserMapper userMapper;
​
  @Transactional
  public void insertUser(User user) {
    try {
      // 开启事务
      SqlSession sqlSession = userMapper.getSqlSessionFactory().openSession(true);
      userMapper.setSqlSession(sqlSession);
​
      // 执行数据库操作
      userMapper.insertUser(user);
​
      // 提交事务
      sqlSession.commit();
    } catch (Exception e) {
      // 回滚事务
      sqlSession.rollback();
      throw e;
    }
  }
}

9.整合druid连接池

如果不使用Spring Boot，可以使用MyBatis和Druid的原生配置方式实现整合。

首先，需要在pom.xml中添加MyBatis和Druid的依赖：

    org.mybatis
    mybatis
    3.5.5




    com.alibaba
    druid
    1.2.6

接下来，创建MyBatis的配置文件mybatis-config.xml，并添加Druid的数据源配置：

然后，在代码中通过代码配置加载MyBatis的配置文件和Mapper接口：

public class Application {
​
    public static void main(String[] args) throws IOException {
        // 创建数据源
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
​
        // 创建SqlSessionFactory
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sessionFactory.setMapperLocations(resolver.getResources("classpath*:mapper/*.xml"));
        sessionFactory.setConfigLocation(resolver.getResource("classpath:mybatis-config.xml"));
​
        // 创建MapperScannerConfigurer
        MapperScannerConfigurer scannerConfigurer = new MapperScannerConfigurer();
        scannerConfigurer.setBasePackage("com.example.mapper");
        scannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
​
        // 创建Spring容器
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(Application.class);
        context.getBeanFactory().registerSingleton("sqlSessionFactory", sessionFactory.getObject());
        context.getBeanFactory().registerSingleton("mapperScannerConfigurer", scannerConfigurer);
        context.refresh();
​
        // 使用Mapper接口
        UserMapper userMapper = context.getBean(UserMapper.class);
        User user = userMapper.getUserById(1L);
        System.out.println(user.getUsername());
​
        context.close();
    }
}

最后，在Mapper接口中使用@Mapper注解标识为MyBatis的映射接口，并使用@Select和@Insert等注解配置SQL语句，与Spring Boot中的使用方式相同。同时，需要在Mapper接口所在的包路径中添加相应的Mapper XML文件，例如UserMapper.xml。

10.整合druid在配置类中配置

可以通过配置类的方式来实现MyBatis和Druid的整合，并配置连接池的一些常用参数。

首先，需要在pom.xml中添加MyBatis和Druid的依赖，与之前的方式相同。

接下来，创建一个配置类来配置MyBatis和Druid的相关内容：

@Configuration
@MapperScan(basePackages = "com.example.mapper", sqlSessionTemplateRef = "sqlSessionTemplate")
public class MyBatisConfig {
​
    @Value("${spring.datasource.url}")
    private String url;
​
    @Value("${spring.datasource.username}")
    private String username;
​
    @Value("${spring.datasource.password}")
    private String password;
​
    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;
​
    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(driverClassName);
        // 配置其他连接池参数
        dataSource.setInitialSize(5);
        dataSource.setMaxActive(20);
        dataSource.setMinIdle(5);
        dataSource.setMaxWait(60000);
        dataSource.setTimeBetweenEvictionRunsMillis(60000);
        dataSource.setMinEvictableIdleTimeMillis(300000);
        dataSource.setValidationQuery("SELECT 1 FROM DUAL");
        dataSource.setTestWhileIdle(true);
        dataSource.setTestOnBorrow(false);
        dataSource.setTestOnReturn(false);
        return dataSource;
    }
​
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(dataSource);
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        sessionFactory.setMapperLocations(resolver.getResources("classpath*:mapper/*.xml"));
        return sessionFactory.getObject();
    }
​
    @Bean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

在配置类中，通过@Value注解来获取配置文件中的相关参数，并创建DruidDataSource作为数据源。然后，再创建SqlSessionFactory和SqlSessionTemplate，并将它们注入到Spring容器中。

接着，在Mapper接口中使用@Mapper注解标识为MyBatis的映射接口，并使用@Select和@Insert等注解配置SQL语句，与Spring Boot中的使用方式相同。同时，需要在Mapper接口所在的包路径中添加相应的Mapper XML文件，例如UserMapper.xml。

最后，在主类中通过注解开启Spring容器，并使用Mapper接口进行数据库操作：

public class Application {
​
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(MyBatisConfig.class);
​
        // 使用Mapper接口
        UserMapper userMapper = context.getBean(UserMapper.class);
        User user = userMapper.getUserById(1L);
        System.out.println(user.getUsername());
​
        ((AnnotationConfigApplicationContext) context).close();
    }
}

四.springmvc

概念：

Spring MVC是一个基于Java的Web框架，用于开发Web应用程序。它是Spring Framework的一部分，提供了一种模型-视图-控制器（Model-View-Controller，MVC）的架构模式来组织和管理Web应用程序的代码。

以下是Spring MVC的一些关键概念：

1. 控制器(Controller)：控制器负责接收和处理用户请求，并根据请求的内容执行相应的业务逻辑。它通常使用注解来标识请求处理方法。

2. 模型(Model)：模型代表Web应用程序中用于处理数据和业务逻辑的对象。它可以是一个Java对象或者一个POJO（Plain Old Java Object）。模型对象的数据可以从数据库、文件、外部API等来源获取。

3. 视图(View)：视图负责展示模型数据给用户，通常是一个HTML页面或者其他类型的视觉表现形式。它可以通过模板引擎（如Thymeleaf、FreeMarker等）来处理动态内容。

4. 视图解析器(View Resolver)：视图解析器负责将逻辑视图名映射为实际的视图对象。它可以根据配置找到匹配的视图模板，并将模型数据合并到视图中生成最终的响应内容。

5. 处理器适配器(Handler Adapter)：处理器适配器负责将控制器和请求进行适配，使得控制器能够正确地处理请求。它根据控制器的类型和请求的类型选择合适的适配器。

6. 拦截器(Interceptor)：拦截器可以在请求处理的各个阶段进行预处理和后处理操作。它可以用于执行一些通用的任务，如日志记录、权限验证等。

7. 视图解析器(View Resolver)：视图解析器负责将逻辑视图名映射为实际的视图对象。它可以根据配置找到匹配的视图模板，并将模型数据合并到视图中生成最终的响应内容。

8. 数据绑定(Data Binding)：数据绑定允许将请求参数自动绑定到控制器方法的参数或模型对象的属性上。它通过将请求参数转换为相应的数据类型来简化数据处理。

Spring MVC提供了丰富的功能和扩展性，使得开发人员可以高效地构建、测试和维护Web应用程序。

1.springmvc的在javaweb中的单独使用

以下是一个简单的Spring MVC示例：

1. 创建Maven项目并引入依赖：

    org.springframework
    spring-webmvc
    5.3.10

1. 配置web.xml文件：

    
        dispatcherServlet
        org.springframework.web.servlet.DispatcherServlet
        
            contextConfigLocation
            /WEB-INF/spring-mvc.xml
        
        1
    
    
    
        dispatcherServlet
        /
    

1. 创建spring-mvc.xml文件：

1. 创建Controller类：

@Controller
public class HelloWorldController {
    
    @RequestMapping("/hello")
    public String hello(Model model) {
        model.addAttribute("message", "Hello World!");
        return "hello";
    }
}

1. 创建视图文件hello.jsp：

    


    
${message}

这个示例中创建了一个简单的Controller类HelloWorldController，其中定义了一个请求路径为/hello的方法hello。该方法使用Model对象将消息添加到模型中，并返回视图名称hello。

在视图hello.jsp中，使用EL表达式${message}来显示传递的消息。

启动项目后，在浏览器中访问http://localhost:8080/hello，将会显示"Hello World!"的消息。

2.springmvc在spring中的使用

以下是一个完全基于注解配置的Spring整合Spring MVC的示例，前端不使用JSP，返回数据为JSON：

1. 创建Maven项目并引入必要依赖：

    org.springframework
    spring-webmvc
    5.3.10

1. 创建Java配置类AppConfig，包含如下内容：

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.example.controller")
public class AppConfig implements WebMvcConfigurer {
​
    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.jsp(); // 禁用JSP视图解析器
    }
​
    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable(); // 启用默认的Servlet处理器
    }
​
    @Bean
    public MappingJackson2HttpMessageConverter jsonConverter() {
        return new MappingJackson2HttpMessageConverter();
    }
​
    @Override
    public void configureMessageConverters(List> converters) {
        converters.add(jsonConverter()); // 注册Json转换器
    }
}

1. 创建Controller类：

@RestController
public class HelloWorldController {
​
    @RequestMapping("/hello")
    public Map hello() {
        Map response = new HashMap<>();
        response.put("message", "Hello World!");
        return response;
    }
}

1. 启动项目后，在浏览器中访问http://localhost:8080/hello，将会返回一个JSON对象：

{
  "message": "Hello World!"
}

在这个示例中，配置类AppConfig中禁用了JSP视图解析器，启用了默认的Servlet处理器，并注册了一个MappingJackson2HttpMessageConverter，用于将Controller方法返回的对象自动转换为JSON

3.springmvc的参数日期格式转换

在Spring MVC中，可以使用@DateTimeFormat注解和Converter进行日期的转换。

首先，在Controller中的方法参数上使用@DateTimeFormat注解进行日期格式的指定，如下所示：

@RequestMapping("/hello")
public String hello(@RequestParam("date") @DateTimeFormat(pattern = "yyyy-MM-dd") Date date) {
    // 处理日期参数
    return "hello";
}

在上述示例中，@DateTimeFormat中的pattern属性指定了日期的格式。

接下来，创建一个自定义的日期转换器实现Converter接口，用于将字符串转换为java.util.Date类型。示例如下：

@Component
public class StringToDateConverter implements Converter {

    @Override
    public Date convert(String source) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        try {
            return dateFormat.parse(source);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
}

在上述示例中，StringToDateConverter实现了将字符串转换为java.util.Date类型的逻辑，使用SimpleDateFormat进行字符串到日期的转换。

最后，在配置类中注册日期转换器，如下所示：

@Configuration
public class AppConfig implements WebMvcConfigurer {

    @Autowired
    private StringToDateConverter stringToDateConverter;

    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(stringToDateConverter);
    }
}

在上述配置中，通过addConverter方法将自定义的日期转换器注册到FormatterRegistry中。

这样，在使用@DateTimeFormat注解指定日期格式的方法参数上，Spring MVC会自动将字符串转换为对应的日期类型

4.全局日期参数自动转换

要在Spring MVC中全局有效地自定义日期消息转换器，你可以按照以下步骤进行操作：

首先，创建一个类实现HandlerMethodArgumentResolver接口，用于自定义日期消息转换逻辑。示例如下：

@Component
public class CustomDateArgumentResolver implements HandlerMethodArgumentResolver {

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return Date.class.isAssignableFrom(parameter.getParameterType());
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
        String parameterValue = webRequest.getParameter(parameter.getParameterName());
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        return dateFormat.parse(parameterValue);
    }
}

在上述示例中，CustomDateArgumentResolver实现了自定义日期消息转换逻辑，在resolveArgument方法中，将请求中携带的日期字符串转换为java.util.Date类型。

然后，在配置类中注册自定义的日期消息转换器，如下所示：

@Configuration
public class AppConfig implements WebMvcConfigurer {

    @Autowired
    private CustomDateArgumentResolver customDateArgumentResolver;

    @Override
    public void addArgumentResolvers(List resolvers) {
        resolvers.add(customDateArgumentResolver);
    }
}

在上述配置中，通过addArgumentResolvers方法将自定义的日期消息转换器添加到Spring MVC的参数解析器列表中。

这样，不需要使用@DateTimeFormat注解，全局有效地自定义日期消息转换器就会生效，Spring MVC会自动将请求中的日期字符串转换为对应的日期类型

5.拦截器

在Spring MVC中，拦截器是一种机制，用于在请求处理的不同阶段进行拦截和处理。拦截器可以在请求进入Controller之前或者之后进行一些处理，例如身份验证、日志记录、权限校验等。以下是在Spring MVC中使用拦截器的步骤：

1. 创建一个实现HandlerInterceptor接口的拦截器类，示例如下：

@Component
public class CustomInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 在Controller处理请求之前进行拦截处理
        // 返回true表示继续执行后续的拦截器和请求处理，返回false表示终止请求处理流程
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // 在Controller处理请求之后、视图渲染之前进行拦截处理
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 在视图渲染之后进行拦截处理，进行资源清理等操作
    }
}

在上述示例中，CustomInterceptor类实现了HandlerInterceptor接口，并通过preHandle、postHandle和afterCompletion方法可以在请求处理的不同阶段进行对应的拦截处理。

1. 在配置类中注册拦截器：

@Configuration
public class AppConfig extends WebMvcConfigurerAdapter {

    @Autowired
    private CustomInterceptor customInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(customInterceptor).addPathPatterns("/**");
    }
}

在上述配置中，通过addInterceptors方法将自定义的拦截器注册到Spring MVC的拦截器列表中，使用addPathPatterns方法指定拦截的URL路径。

通过以上步骤，就可以在Spring MVC中使用拦截器来拦截和处理请求。拦截器可以在Controller之前或者之后进行一些通用的处理逻辑，提供了一种灵活且低耦合的机制来增强应用

6.拦截器的路径配置

在Spring MVC中，拦截器的路径配置可以通过以下方式来实现：

1. 拦截所有请求：

registry.addInterceptor(customInterceptor).addPathPatterns("/**");

通过使用"**"作为路径模式，可以拦截应用中的所有请求。这样配置的拦截器将会应用于所有的请求路径。

1. 拦截指定路径的请求：

registry.addInterceptor(customInterceptor).addPathPatterns("/path1", "/path2");

可以使用字符串参数来指定拦截器要拦截的具体路径。在上述示例中，拦截器将会应用于路径为/path1和/path2的请求。

1. 拦截特定路径下的所有请求：

registry.addInterceptor(customInterceptor).addPathPatterns("/api/*");

可以使用通配符"*"来匹配路径的部分内容。在上述示例中，拦截器将会应用于以/api/开头的所有请求路径。

1. 排除拦截某些请求路径：

registry.addInterceptor(customInterceptor).excludePathPatterns("/path1", "/path2");

除了指定拦截的路径外，还可以使用excludePathPatterns方法来排除某些路径不被拦截。在上述示例中，拦截器将不会应用于路径为/path1和/path2的请求。

通过以上方式，可以灵活地配置拦截器的路径，以满足不同场景下的需求。

7.拦截器和过滤器的区别

拦截器和过滤器是在Web开发中常用的两种组件，它们的作用都是对请求进行处理和拦截，但是在实现机制上有一些区别。

1. 生命周期：

• 过滤器(Filter)是Servlet规范中的一部分，在请求进入Servlet容器之后、进入Servlet之前，以及响应返回客户端之前的各个阶段都可以通过过滤器进行处理。过滤器的生命周期由Servlet容器管理，即在容器启动时就会被加载，请求结束后被销毁。

• 拦截器(Interceptor)是Spring MVC框架中的一部分，它的生命周期由Spring容器管理。拦截器在DispatcherServlet前后以及Controller处理请求之前和之后进行拦截。

1. 执行顺序：

• 过滤器(Filter)在请求进入Servlet容器之后第一个执行，然后按照指定的顺序依次执行后续过滤器。最后在请求返回客户端之前，以相反的顺序执行过滤器的销毁方法。

• 拦截器(Interceptor)在请求进入Servlet之前和Controller处理请求之前执行，然后按照指定的顺序依次执行后续拦截器。再在Controller处理请求之后、视图渲染之前执行，最后以相反的顺序执行拦截器的销毁方法。

1. 使用范围：

• 过滤器(Filter)可以对所有的请求进行拦截，包括静态资源和动态请求。它是在Servlet容器级别进行拦截，所以可以拦截任何类型的请求。

• 拦截器(Interceptor)通常用于拦截对应用中的指定请求进行处理。它是在Web框架级别进行拦截，所以只能拦截到由该框架进行处理的请求。

总的来说，过滤器(Filter)是对请求进行全局的处理和拦截，适合处理一些与业务无关的通用逻辑，如字符编码、安全认证、日志记录等。拦截器(Interceptor)更加灵活，它是在框架级别进行拦截，适合处理与业务相关的请求处理逻辑，如权限验证、日志记录、事务管理等

8.跨域配置

在Spring MVC中配置跨域请求可以通过两种方式实现：

1. 使用注解@Configuration和类CorsRegistry 创建一个配置类，使用@Configuration注解标注该类，然后定义一个方法来配置跨域请求。在该方法上添加@Bean注解，返回一个WebMvcConfigurer对象，通过重写addCorsMappings方法来配置跨域请求的规则。

例子：

@Configuration
public class CorsConfig {
    @Bean
    public WebMvcConfigurer corsConfigurer() {
        return new WebMvcConfigurer() {
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/api/**")
                        .allowedOrigins("http://localhost:8080")
                        .allowedMethods("GET", "POST", "PUT", "DELETE")
                        .allowedHeaders("*")
                        .allowCredentials(false)
                        .maxAge(3600);
            }
        };
    }
}

上述例子中，配置了允许来自"http://localhost:8080"的跨域请求访问"/api/**"路径下的资源，并指定了允许的请求方法、请求头、是否允许携带凭证和预检请求的缓存时间。

1. 使用过滤器实现跨域请求 创建一个过滤器，在doFilter方法中添加相关的跨域请求处理逻辑，并在web.xml或Servlet注册类中配置该过滤器。

例子：

@WebFilter(urlPatterns = "/*")
public class CorsFilter implements Filter {
    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;
​
        response.setHeader("Access-Control-Allow-Origin", "http://localhost:8080");
        response.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE");
        response.setHeader("Access-Control-Allow-Headers", "*");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Credentials", "false");
​
        chain.doFilter(req, res);
    }
}

9.放行静态资源

在Spring MVC中，如果需要放行静态资源，可以通过配置WebMvcConfigurer的addResourceHandlers方法来实现。

在你的配置类中，添加如下代码：

@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/static/**")
                .addResourceLocations("classpath:/static/");
    }
}

上述例子中，配置了访问路径为"/static/"**的静态资源，并将它们的位置设置为"classpath:/static/"。

假设你的静态资源都位于src/main/resources/static目录下，那么你可以直接在浏览器中访问http://localhost:8080/static/xxx.xxx 来获取静态资源（这里的xxx.xxx是静态资源文件名）。

这样配置之后，Spring MVC会优先匹配静态资源的访问路径，如果匹配成功则返回对应的静态资源，如果不匹配则继续匹配其他的请求路径

五.springboot

概念：

Spring Boot是一个用于创建和部署独立、生产级别的Spring应用程序的框架。它是基于Spring框架的扩展，旨在简化Spring应用程序的开发和配置。下面是Spring Boot的一些关键概念：

1. 自动配置(Auto-configuration)：Spring Boot采用了约定大于配置的原则，根据应用程序的依赖关系自动配置Spring和第三方库。通过自动配置，开发人员可以更方便地快速启动和部署应用程序。

2. 起步依赖(Starter Dependencies)：Spring Boot提供了一系列的“起步依赖”，这些依赖可以为特定的场景或应用程序类型提供必需的库和配置。开发人员可以根据自己的需求选择合适的起步依赖，而不需要手动引入和配置依赖。

3. 嵌入式服务器(Embedded Server)：Spring Boot内置了多种嵌入式服务器，如Tomcat、Jetty等。开发人员可以将应用程序打包成一个可执行的JAR文件，并直接运行，而不需要额外安装和配置服务器。

4. 简化的配置(Configuration Simplification)：Spring Boot通过提供默认配置和约定大于配置的原则，减少了开发人员需要编写的配置代码。开发人员可以通过application.properties或application.yml文件进行自定义配置。

5. 健康检查(Health Check)：Spring Boot提供了健康检查功能，开发人员可以通过HTTP端点或管理界面查看应用程序的健康状态。这对于监控和故障排除非常有帮助。

6. 外部化配置(Externalized Configuration)：Spring Boot支持将应用程序的配置从代码中分离出来，可以使用环境变量、属性文件、命令行参数等多种方式进行配置。这使得应用程序的配置更加灵活和易于管理。

Spring Boot的目标是让开发人员能够更快、更容易地创建独立的、生产级别的Spring应用程序。它提供了丰富的功能和扩展性，同时保持了Spring框架的灵活性和强大性。

1.springboot的搭建

要在IntelliJ IDEA中快速搭建一个Spring Boot项目，可以按照以下步骤进行操作：

1. 打开IntelliJ IDEA，点击 "Create New Project"（或者在欢迎界面点击 "New Project"）。

2. 在弹出的 "New Project" 窗口中，选择 "Spring Initializr" 选项，并点击 "Next"。

3. 在下一个界面中，选择以下配置项：

   • 选择项目类型为 "Maven"

   • 填写 "Group" 和 "Artifact" 信息，作为项目的唯一标识，一般以com.xxx。

   • 选择项目的 "Language"，选择 Java

4. 选择项目的默认配置项，如"Packaging"（打包方式）为jar包

5. 在 "Project SDK" 配置中，选择您已经安装好的 Java ,jdk版本为8。

6. 点击 "Next"，然后选择项目的名称和保存路径。

7. 点击 "Finish"，IntelliJ IDEA 将会根据您的配置下载所需的依赖项并创建项目。

8. 创建完成后，可以在项目的 "src/main/java" 目录下找到启动类（例如：DemoApplication.java），这是一个 Spring Boot 应用的入口类。

9. 。在main下面新建一个resources目录,然后在该目录中新建一个application.yml配置文件，该文件为springboot的配置文件

2.springboot中开发web项目的依赖

在pom.xml文件中引入依赖：

1. （1）.引入springmvc依赖

2. 在 标签内添加如下依赖项：

    org.springframework.boot
    spring-boot-starter-web

（2）.引入mysql连接依赖**

    mysql
    mysql-connector-java

（3）引入druid启动依赖

  com.alibaba
  druid-spring-boot-starter
  xxx

（4）.引入mybatis-plus依赖**

    com.baomidou
    mybatis-plus-boot-starter
    {版本号}

（5）.引入lombok依赖

    org.projectlombok
    lombok
    {版本号}

以上就可以基本实现一个增删改查的项目了

3.对以上依赖的相关配置

在application.yml文件中添加相关配置

(1)对端口配置

server:
  port:  8080

(2).对mysql和druid连接池配置

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydatabase
    username: root
    password: your_password
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource  # 指定使用Druid数据源
    druid:
      initial-size: 5  # 初始连接数
      min-idle: 5  # 最小空闲连接数
      max-active: 20  # 最大活跃连接数
      test-on-borrow: false  # 从连接池中取出连接时是否进行测试，默认为false
      filters: stat,wall  # 过滤器配置，可根据需要添加更多过滤器

(3)对mybatis-plus的配置

mybatis-plus:
  mapper-locations: classpath:mapper/*.xml
  global-config:
    db-config:
      id-type: auto  # 主键生成策略，可选值有：AUTO、INPUT、ID_WORKER、ID_WORKER_STR、UUID、NONE
  configuration:
    map-underscore-to-camel-case: true  # 开启驼峰命名转换

其他配置看上面的mybatis-plus配置

好了，以上就对基本的相关做了配置，下面我们来做一个简单示例：

4.springboot的简单示例

1. 创建实体类 创建一个名为 User 的实体类，同时使用 Lombok 的 @Data 注解标记该类，并指定表名为 tb_user，标记 id 为主键，策略为雪花。代码如下：

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
​
@Data
@TableName("tb_user")
public class User {
    @TableId(type = IdType.ASSIGN_UUID)
    private String id;
    private String username;
    private String password;
}

1. 创建 Mapper 接口 在 mapper 包下创建名为 UserMapper 的接口，继承 BaseMapper 接口，并为 User 实体类指定泛型。代码如下：

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.springframework.stereotype.Repository;
​
@Repository
public interface UserMapper extends BaseMapper {
}

1. 创建 Service 接口和实现类 在 service 包下创建名为 UserService 的接口，继承 IService 接口，并为 User 实体类指定泛型。代码如下：

import com.baomidou.mybatisplus.extension.service.IService;
​
public interface UserService extends IService {
    // 可自行定义其他业务方法
}

接着，在 service.impl 包下创建名为 UserServiceImpl 的实现类，继承 ServiceImpl 类，并为 User 实体类和 UserMapper 接口指定泛型。代码如下：

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
​
@Service
public class UserServiceImpl extends ServiceImpl implements UserService {
​
    @Override
    public boolean saveUser(User user) {
        return save(user);
    }
​
    @Override
    public boolean updateUser(User user) {
        return updateById(user);
    }
​
    @Override
    public boolean deleteUser(String id) {
        return removeById(id);
    }
​
    @Override
    public User getUserById(String id) {
        return getById(id);
    }
​
    @Override
    public List getAllUsers() {
        return list();
    }
​
    @Override
    public List getUsersByUsername(String username) {
        LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getUsername, username);
        return list(queryWrapper);
    }
}

1. 创建 Controller 类 在 controller 包下创建名为 UserController 的类，使用 @RestController 注解标识该类为控制器类，代码如下：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
​
@RestController
@RequestMapping("/users")
public class UserController {
​
    @Autowired
    private UserService userService;
​
    @PostMapping
    public boolean saveUser(@RequestBody User user) {
        userService.save(user);
    }
​
    @PutMapping
    public boolean updateUser(@RequestBody User user) {
        userService.updateById(user);
    }
​
    @DeleteMapping("/{id}")
    public boolean deleteUser(@PathVariable String id) {
        userService.removeById(id);
    }
​
    @GetMapping("/{username}")
    public List getUserById(@PathVariable String username) {
        return userService.getByUserName(username);
    }
}

这样，您已经完成了一个简单的增删改查示例。请确保正确配置数据库连接信息和 MyBatis Plus 的配置，以及各个包的扫描路径等

5.分页查询示例

1. 创建一个配置类 MyBatisPlusConfig，配置分页拦截器：

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
​
@Configuration
public class MyBatisPlusConfig {
​
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

1. 创建一个分页查询的 Controller：

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
​
@RestController
public class UserController {
​
    @Autowired
    private UserService userService;
​
    @GetMapping("/users")
    public IPage getUsersByPage(@RequestParam(defaultValue = "1") Integer pageNum,
                                      @RequestParam(defaultValue = "10") Integer pageSize) {
        Page page = new Page<>(pageNum, pageSize);
        return userService.page(page);
    }
}

1. 创建一个 Service 接口和实现类，使用 MyBatis-Plus 提供的分页查询方法：

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
​
public interface UserService extends IService {
​
    IPage getUsersByPage(Integer pageNum, Integer pageSize);
}
​
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
​
@Service
public class UserServiceImpl extends ServiceImpl implements UserService {
​
    @Override
    public IPage getUsersByPage(Integer pageNum, Integer pageSize) {
        Page page = new Page<>(pageNum, pageSize);
        return baseMapper.selectPage(page, null);
    }
}

6.LambdQueryWrapper

好的，下面是使用 LambdaQueryWrapper 进行模糊查询、等值查询和比较查询的示例：

1. 模糊查询示例：

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
​
@RestController
public class UserController {
​
    @Autowired
    private UserService userService;
​
    @GetMapping("/users")
    public List getUsers(@RequestParam String keyword) {
        LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.like(User::getUsername, keyword);
        return userService.list(lambdaQueryWrapper);
    }
}

在上面的示例中，我们使用 like 方法进行模糊查询，查询条件为 username 字段中包含关键字的记录。使用 LambdaQueryWrapper 可以直接通过实体类的属性进行字段的操作。

1. 等值查询示例：

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
​
@RestController
public class UserController {
​
    @Autowired
    private UserService userService;
​
    @GetMapping("/users")
    public List getUsers(@RequestParam Integer age) {
        LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(User::getAge, age);
        return userService.list(lambdaQueryWrapper);
    }
}

在上面的示例中，我们使用 eq 方法进行等值查询，查询条件为 age 字段等于给定的年龄值。

1. 比较查询示例：

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
​
@RestController
public class UserController {
​
    @Autowired
    private UserService userService;
​
    @GetMapping("/users")
    public List getUsers(@RequestParam Integer minAge, @RequestParam Integer maxAge) {
        LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.between(User::getAge, minAge, maxAge);
        return userService.list(lambdaQueryWrapper);
    }
}

在上面的示例中，我们使用 between 方法进行比较查询，查询条件为 age 字段在给定的最小年龄值和最大年龄值之间的记录。

7.springboot中配置跨域

在Spring Boot中配置跨域请求可以通过以下几种方式来实现：

1. 使用@CrossOrigin注解：可以在具体的Controller类或者某个特定的方法上使用此注解来配置跨域请求。

@RestController
@CrossOrigin(origins = "http://localhost:8080")
public class MyController {
    // Controller的方法
}

上述代码将允许来自http://localhost:8080的跨域请求访问该Controller。

1. 使用全局配置CorsFilter：创建一个全局过滤器来处理跨域请求，在WebConfig类中进行配置。

@Configuration
public class WebConfig implements WebMvcConfigurer {
​
    @Bean
    public CorsFilter corsFilter() {
        CorsConfiguration config = new CorsConfiguration();
        config.addAllowedOrigin("http://localhost:8080");
        config.addAllowedMethod("*");
        config.addAllowedHeader("*");
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", config);
        return new CorsFilter(source);
    }
}

上述代码中，config.addAllowedOrigin("http://localhost:8080")指定了允许跨域请求的源。config.addAllowedMethod("*")允许所有HTTP方法，config.addAllowedHeader("*")允许所有头部信息。

1. 使用自定义拦截器：可以创建一个拦截器来处理跨域请求，在拦截器中完成相关配置。

@Configuration
public class WebConfig extends WebMvcConfigurationSupport {
​
    @Override
    protected void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("http://localhost:8080")
                .allowedMethods("*")
                .allowedHeaders("*");
    }
}

上述代码中，通过重写addCorsMappings方法来添加跨域配置。

你可能感兴趣的:(spring,java,spring,java,后端)

• Long类型前后端数据不一致 igotyback 前端
  响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
• LocalDateTime 转 String igotyback java开发语言
  importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
• Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
  需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
• 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
  目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
• DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
  ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
• 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
  华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
• 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
  ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
• HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
  Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
• node.js学习 小猿L node.jsnode.js学习vim
  node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
• Low Power概念介绍-Voltage Area 飞奔的大虎
  随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
• SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
  SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
• Java 重写(Override)与重载(Overload) 叨唧唧的
  Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
• 简单了解 JVM 记得开心一点啊 jvm
  目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
• 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
  1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
• Java企业面试题3 马龙强_ java
  1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
• JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
  Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
• Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
  一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
• 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
  欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
• python语法——三目运算符 HappyRocking pythonpython三目运算符
  在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
• spring如何整合druid连接池？ 惜.己 springspringjunit数据库javaidea后端xml
  目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
• ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
  ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
• Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
  一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
• Java：爬虫框架 dingcho Javajava爬虫
  一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
• python怎么将png转为tif_png转tif weixin_39977276
  发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
• SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
  前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
• springboot+vue项目实战一-创建SpringBoot简单项目 苹果酱0567 面试题汇总与解析springboot后端java中间件开发语言
  这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
• JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
  在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
• uniapp map组件自定义markers标记点 以对_ uni-app学习记录uni-appjavascript前端
  需求是根据后端返回数据在地图上显示标记点，并且根据数据状态控制标记点颜色，标记点背景通过两张图片实现控制{{item.options.labelName}}exportdefault{data(){return{storeIndex:0,locaInfo:{longitude:120.445172,latitude:36.111387},markers:[//标点列表{id:1,//标记点idin
• JAVA·一个简单的登录窗口 MortalTom java开发语言学习
  文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
• 笋丁网页自动回复机器人V3.0.0免授权版源码 希希分享 软希网58soho_cn源码资源笋丁网页自动回复机器人
  笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
• 关于旗正规则引擎规则中的上传和下载问题 何必如此 文件下载压缩jsp文件上传
  文件的上传下载都是数据流的输入输出，大致流程都是一样的。 一、文件打包下载 1.文件写入压缩包 string mainPath="D:\upload\";     下载路径 string tmpfileName=jar.zip;        &n
• 【Spark九十九】Spark Streaming的batch interval时间内的数据流转源码分析 bit1129 Stream
    以如下代码为例（SocketInputDStream）： Spark Streaming从Socket读取数据的代码是在SocketReceiver的receive方法中，撇开异常情况不谈(Receiver有重连机制，restart方法，默认情况下在Receiver挂了之后，间隔两秒钟重新建立Socket连接)，读取到的数据通过调用store(textRead)方法进行存储。数据
• spark master web ui 端口8080被占用解决方法 daizj 8080端口占用sparkmaster web ui
  spark master web ui 默认端口为8080，当系统有其它程序也在使用该接口时，启动master时也不会报错，spark自己会改用其它端口，自动端口号加1，但为了可以控制到指定的端口，我们可以自行设置，修改方法：   1、cd SPARK_HOME/sbin   2、vi start-master.sh     3、定位到下面部分
• oracle_执行计划_谓词信息和数据获取 周凡杨 oracle执行计划
    oracle_执行计划_谓词信息和数据获取(上) 一：简要说明 在查看执行计划的信息中，经常会看到两个谓词filter和access，它们的区别是什么，理解了这两个词对我们解读Oracle的执行计划信息会有所帮助。 简单说，执行计划如果显示是access，就表示这个谓词条件的值将会影响数据的访问路径（表还是索引），而filter表示谓词条件的值并不会影响数据访问路径，只起到
• spring中datasource配置 g21121 dataSource
  datasource配置有很多种，我介绍的一种是采用c3p0的，它的百科地址是： http://baike.baidu.com/view/920062.htm   <!-- spring加载资源文件 --> <bean name="propertiesConfig" class="org.springframework.b
• web报表工具FineReport使用中遇到的常见报错及解决办法（三） 老A不折腾 finereportFAQ报表软件
  这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。   出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 1、repeated column width is largerthan paper width： 这个看这段话应该是很好理解的。比如做的模板页面宽度只能放
• mysql 用户管理 墙头上一根草 linuxmysqluser
  1.新建用户 //登录MYSQL@>mysql -u root -p@>密码//创建用户mysql> insert into mysql.user(Host,User,Password) values(‘localhost’,'jeecn’,password(‘jeecn’));//刷新系统权限表mysql>flush privileges;这样就创建了一个名为：
• 关于使用Spring导致c3p0数据库死锁问题 aijuans springSpring 入门Spring 实例Spring3Spring 教程
  这个问题我实在是为整个 springsource 的员工蒙羞 如果大家使用 spring 控制事务，使用 Open Session In View 模式， com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.
• 百度词库联想 annan211 百度
  <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>RunJS</title&g
• int数据与byte之间的相互转换实现代码 百合不是茶 位移int转bytebyte转int基本数据类型的实现
  在BMP文件和文件压缩时需要用到的int与byte转换,现将理解的贴出来;   主要是要理解;位移等概念 http://baihe747.iteye.com/blog/2078029   int转byte;   byte转int;   /** * 字节转成int,int转成字节 * @author Administrator *
• 简单模拟实现数据库连接池 bijian1013 javathreadjava多线程简单模拟实现数据库连接池
  简单模拟实现数据库连接池 实例1： package com.bijian.thread; public class DB { //private static final int MAX_COUNT = 10; private static final DB instance = new DB(); private int count = 0; private i
• 一种基于Weblogic容器的鉴权设计 bijian1013 javaweblogic
          服务器对请求的鉴权可以在请求头中加Authorization之类的key，将用户名、密码保存到此key对应的value中，当然对于用户名、密码这种高机密的信息，应该对其进行加砂加密等，最简单的方法如下： String vuser_id = "weblogic"; String vuse
• 【RPC框架Hessian二】Hessian 对象序列化和反序列化 bit1129 hessian
   任何一个对象从一个JVM传输到另一个JVM，都要经过序列化为二进制数据(或者字符串等其他格式，比如JSON)，然后在反序列化为Java对象，这最后都是通过二进制的数据在不同的JVM之间传输(一般是通过Socket和二进制的数据传输)，本文定义一个比较符合工作中。   1. 定义三个POJO    Person类 package com.tom.hes
• 【Hadoop十四】Hadoop提供的脚本的功能 bit1129 hadoop
  1. hadoop-daemon.sh 1.1 启动HDFS ./hadoop-daemon.sh start namenode ./hadoop-daemon.sh start datanode  通过这种逐步启动的方式，比start-all.sh方式少了一个SecondaryNameNode进程，这不影响Hadoop的使用，其实在 Hadoop2.0中，SecondaryNa
• 中国互联网走在“灰度”上 ronin47 管理 灰度
  中国互联网走在“灰度”上（转） 文/孕峰   第一次听说灰度这个词，是任正非说新型管理者所需要的素质。第二次听说是来自马化腾。似乎其他人包括马云也用不同的语言说过类似的意思。   灰度这个词所包含的意义和视野是广远的。要理解这个词，可能同样要用“灰度”的心态。灰度的反面，是规规矩矩，清清楚楚，泾渭分明，严谨条理，是决不妥协，不转弯，认死理。黑白分明不是灰度，像彩虹那样
• java-51-输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。 bylijinnan java
  public class PrintMatrixClockwisely { /** * Q51.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。 例如：如果输入如下矩阵： 1 2 3 4 5 6 7 8 9
• mongoDB 用户管理 开窍的石头 mongoDB用户管理
    1:添加用户    第一次设置用户需要进入admin数据库下设置超级用户（use admin）      db.addUsr({user:'useName',pwd:'111111',roles:[readWrite,dbAdmin]});    第一个参数用户的名字    第二个参数
• [游戏与生活]玩暗黑破坏神3的一些问题 comsci 生活
      暗黑破坏神3是有史以来最让人激动的游戏。。。。但是有几个问题需要我们注意      玩这个游戏的时间，每天不要超过一个小时，且每次玩游戏最好在白天      结束游戏之后，最好在太阳下面来晒一下身上的暗黑气息，让自己恢复人的生气   &nb
• java 二维数组如何存入数据库 cuiyadll java
  using System; using System.Linq; using System.Text; using System.Windows.Forms; using System.Xml; using System.Xml.Serialization; using System.IO; namespace WindowsFormsApplication1 {
• 本地事务和全局事务Local Transaction and Global Transaction(JTA) darrenzhu javaspringlocalglobaltransaction
  Configuring Spring and JTA without full Java EE http://spring.io/blog/2011/08/15/configuring-spring-and-jta-without-full-java-ee/ Spring doc -Transaction Management http://docs.spring.io/spri
• Linux命令之alias - 设置命令的别名，让 Linux 命令更简练 dcj3sjt126com linuxalias
  用途说明 设置命令的别名。在linux系统中如果命令太长又不符合用户的习惯，那么我们可以为它指定一个别名。虽然可以为命令建立“链接”解决长文件名的问 题，但对于带命令行参数的命令，链接就无能为力了。而指定别名则可以解决此类所有问题【1】。常用别名来简化ssh登录【见示例三】，使长命令变短，使常 用的长命令行变短，强制执行命令时询问等。   常用参数 格式：alias 格式：ali
• yii2 restful web服务[格式响应] dcj3sjt126com PHPyii2
  响应格式 当处理一个 RESTful API 请求时， 一个应用程序通常需要如下步骤 来处理响应格式： 确定可能影响响应格式的各种因素， 例如媒介类型， 语言， 版本， 等等。 这个过程也被称为 content negotiation。 资源对象转换为数组， 如在 Resources 部分中所描述的。 通过 [[yii\rest\Serializer]]
• MongoDB索引调优（2）——[十] eksliang mongodbMongoDB索引优化
  转载请出自出处：http://eksliang.iteye.com/blog/2178555 一、概述       上一篇文档中也说明了，MongoDB的索引几乎与关系型数据库的索引一模一样，优化关系型数据库的技巧通用适合MongoDB，所有这里只讲MongoDB需要注意的地方 二、索引内嵌文档     可以在嵌套文档的键上建立索引，方式与正常
• 当滑动到顶部和底部时，实现Item的分离效果的ListView gundumw100 android
  拉动ListView，Item之间的间距会变大，释放后恢复原样； package cn.tangdada.tangbang.widget; import android.annotation.TargetApi; import android.content.Context; import android.content.res.TypedArray; import andr
• 程序员用HTML5制作的爱心树表白动画 ini JavaScriptjqueryWebhtml5css
  体验效果：http://keleyi.com/keleyi/phtml/html5/31.htmHTML代码如下： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"><head><meta charset="UTF-8" > <ti
• 预装windows 8 系统GPT模式的ThinkPad T440改装64位 windows 7旗舰版 kakajw ThinkPad预装改装windows 7windows 8
    该教程具有普遍参考性，特别适用于联想的机器，其他品牌机器的处理过程也大同小异。 该教程是个人多次尝试和总结的结果，实用性强，推荐给需要的人！   缘由 小弟最近入手笔记本ThinkPad T440，但是特别不能习惯笔记本出厂预装的Windows 8系统，而且厂商自作聪明地预装了一堆没用的应用软件，消耗不少的系统资源（本本的内存为4G，系统启动完成时，物理内存占用比
• Nginx学习笔记 mcj8089 nginx
  一、安装nginx             1、在nginx官方网站下载一个包，下载地址是：  http://nginx.org/download/nginx-1.4.2.tar.gz      2、WinSCP(ftp上传工
• mongodb 聚合查询每天论坛链接点击次数 qiaolevip 每天进步一点点学习永无止境mongodb纵观千象
  /* 18 */ { "_id" : ObjectId("5596414cbe4d73a327e50274"), "msgType" : "text", "sendTime" : ISODate("2015-07-03T08:01:16.000Z"
• java术语（PO/POJO/VO/BO/DAO/DTO） Luob. DAOPOJODTOpoVO BO
  PO(persistant object) 持久对象 在o/r 映射的时候出现的概念,如果没有o/r映射,就没有这个概念存在了.通常对应数据模型(数据库),本身还有部分业务逻辑的处理.可以看成是与数据库中的表相映射的java对象.最简单的PO就是对应数据库中某个表中的一条记录,多个记录可以用PO的集合.PO中应该不包含任何对数据库的操作. VO(value object) 值对象 通
• 算法复杂度 Wuaner Algorithm
  Time Complexity & Big-O： http://stackoverflow.com/questions/487258/plain-english-explanation-of-big-o http://bigocheatsheet.com/ http://www.sitepoint.com/time-complexity-algorithms/

按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他

首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.