第十四天。

qw1231rt

已于 2023-03-10 10:10:01 修改

阅读量70

点赞数

分类专栏：每日文章标签： java Powered by 金山文档

于 2023-03-09 21:08:43 首次发布

本文链接：https://blog.csdn.net/qw1231rt/article/details/129417743

版权

每日专栏收录该内容

26 篇文章 0 订阅

订阅专栏

练习

得到 K 个黑块的最少涂色次数

得到 K 个黑块的最少涂色次数
提示
简单
49
相关企业
给你一个长度为 n 下标从 0 开始的字符串 blocks ，blocks[i] 要么是 'W' 要么是 'B' ，表示第 i 块的颜色。字符 'W' 和 'B' 分别表示白色和黑色。

给你一个整数 k ，表示想要 连续 黑色块的数目。

每一次操作中，你可以选择一个白色块将它 涂成 黑色块。

请你返回至少出现 一次 连续 k 个黑色块的 最少 操作次数。

 

示例 1：

输入：blocks = "WBBWWBBWBW", k = 7
输出：3
解释：
一种得到 7 个连续黑色块的方法是把第 0 ，3 和 4 个块涂成黑色。
得到 blocks = "BBBBBBBWBW" 。
可以证明无法用少于 3 次操作得到 7 个连续的黑块。
所以我们返回 3 。
示例 2：

输入：blocks = "WBWBBBW", k = 2
输出：0
解释：
不需要任何操作，因为已经有 2 个连续的黑块。
所以我们返回 0 。
 

提示：

n == blocks.length
1 <= n <= 100
blocks[i] 要么是 'W' ，要么是 'B' 。
1 <= k <= n

class Solution {
    public int minimumRecolors(String blocks, int k) {
        int whitenum=0;//记录白色方块出现的次数
        for (int i = 0; i < k; i++) {//为了取连续的k
            whitenum = whitenum + (blocks.charAt(i)=='W' ? 1:0);//三元运算 不习惯的可以换成else if
        }
        int res = whitenum;
        //第一个遍历出的窗口，所以接下来就是右移判断
        for (int i = k; i <blocks.length(); i++) {//窗口滑动
            whitenum = whitenum+ (blocks.charAt(i)=='W'? 1:0);
            whitenum = whitenum- (blocks.charAt(i-k)=='W'? 1:0);
            res = Math.min(res,whitenum);
        }
        return res;
    }
}

感觉跟之前一道判断ab的题有点像

那个是以指针判断左右两边要变的字母

这个是判断在0-K值的窗口下有多少白色方块

思路

将0-k看成一个窗口观察窗口内是否都是连续的黑色方块

如果不是，记录白色方块(因为题意是可以改变白色方块变黑色记录连续的K的最小次数)

然后，再次遍历，整体移动窗口，向右移一个就让记录白色方块的值改变

右移白色方块左边(I-K)判断是不是W 是就-1 不是就返回0

右移白色方块右边(i) 判断是不是W 是就+1 不是就返回0

记录一个数res(最终返回值) 让他记录每次窗口移动所需改变白色方块的最小值

返回res

自己做的时候没想到还能让窗口移动，光想着跟之前一样ab那题

去定义一个指针然后让指针判断前面的是不是连续的后面是不是连续的，不是就变

然后发现有直接返回0的

就发现肯定不是之前那道题的做法

虽然最后判断出来是要记录最小白色方块了，但是真没想到可以整体移动

我想着一个一个的遍历呢

八股

动态代理是什么？有哪些应用？

动态代理就是对某个实现接口类的方法添加额外的处理，例如加事务加日志加权限

spring的AOP就是这个原理，在原本类的基础上创建新的类，新的类增加了更多的功能

扩展更强，而且是动态生成

怎么实现动态代理？

定义一个接口一个InvocationHandler将实现接口类处理的处理类

再有一个代理类也就是工具类利用newInstance反射产生代理对象，然后在通过加载器将实例序列化返回

为什么要使用克隆

想要对一个对象处理，又不想改变原来的数据，就需要克隆

如何实现对象克隆

Cloneable 直接object.clone方法

Serializable序列化反序列化实现克隆，这样比上面的好，因为出现错误可以在编译器阶段通过泛型看到

而不是在允许过程中报错看见

基于阳哥第二季的SpringCloud(第一天)

再次吐槽下，阳哥笔记好的我都不知道该写什么了

直接粘贴阳哥笔记的我真的很屑啊

继续吐槽下学了一会了发现阳哥脑图是真的全啊这还记笔记呢记一下重点得了

订单支付模块微服务--8001

微服务模块

建立module

改pom

写yml

主启动

业务类

controller调service service调dao

创建工程


1  新建Empty Project，类似工作空间
 
2  新project设置
    2.1    project都选择8
    2.2    module点击+号，新建一个maven模块
 
3  新Module的设置
    3.1    由于第一个是pom统一工程，不选择模板create from archetype
 
    3.2    G:com.atguigu.springcloud
         A:microservicecloud
         V:1.0-SNAPSHOT
 
    3.3    Language Level 选择 8
 
 
4  新project设置
    4.1    Editor | File Encodings 设置为UTF8
    4.2    Build, Execution, Deployment | Compiler | Annotation Processors 每个module都打勾
    4.3    File | Settings | Build, Execution, Deployment | Compiler | Java Compiler  设置为1.8
 
5  microservicecloud该模块下鼠标右键新建其下的子module
    5.1    新建子module    microservicecloud-api   可以不勾选create from archetype
    5.2    IDEA工具右边的maven projects视图刷新，出现新的子模块
    5.3    右上角设置，选择Group Modules
    5.4    视图上选择+号，选中api里面的pom.xml
 
6  IDEA工具隐藏*.iml等
    点击File-->setting(或者Ctrl+Alt+S)-->Editor--> Flie Types 在ignore files and folders，然后在输入框最后面跟上*.idea;*.iml;

http://t.csdn.cn/5J5sq

上面是介绍maven pom的 packing默认打包jar

父类型都是pom文件 jar内部调用或者服务调用 war打包用于容器部署

pom文件

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>


    <groupId>com.atguigu.springcloud</groupId>
    <artifactId>cloud2023</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <modules>
        <module>cloud-provider-payment8001</module>
    </modules>


    <!-- 统一管理jar包版本 -->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
        <mysql.version>5.1.47</mysql.version>
        <druid.version>1.1.16</druid.version>
        <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
    </properties>

    <!--dependencyManagement
    子模块继承之后，提供作用：锁定版本+子modlue不用写groupId和version  -->
    <dependencyManagement>
        <dependencies>
            <!--spring boot 2.7.4-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.7.4</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--spring cloud 2021.0.6-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>2021.0.6</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--spring cloud alibaba 2021.0.4.0*-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2021.0.4.0</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.spring.boot.version}</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <optional>true</optional>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <fork>true</fork>
                    <addResources>true</addResources>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

Maven中的DependencyManagement和Dependencies -父项目一次修改，子模块处处用

Maven 使用dependencyManagement 元素来提供了一种管理依赖版本号的方式。

通常会在一个组织或者项目的最顶层的父POM 中看到dependencyManagement 元素。

使用pom.xml 中的dependencyManagement 元素能让所有在子项目中引用一个依赖而不用显式的列出版本号。

Maven 会沿着父子层次向上走，直到找到一个拥有dependencyManagement 元素的项目，然后它就会使用这个

dependencyManagement 元素中指定的版本号。

这样做的好处就是：如果有多个子项目都引用同一样依赖，则可以避免在每个使用的子项目里都声明一个版本号，这样当想升级或切换到另一个版本时，只需要在顶层父容器里更新，而不需要一个一个子项目的修改；另外如果某个子项目需要另外的一个版本，只需要声明version就可。

dependencyManagement里只是声明依赖，并不实现引入，因此子项目需要显示的声明需要用的依赖。

如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且version和scope都读取自父pom;

如果子项目中指定了版本号，那么会使用子项目中指定的jar版本。

支付模块创建

子工程pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>cloud2023</artifactId>
        <groupId>com.atguigu.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-provider-payment8001</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--mysql-connector-java-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

application.yml文件

server:
  port: 8001

spring:
  application:
    name: cloud-payment-service
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包 com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db2019?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: 123456


mybatis:
  mapperLocations: classpath:mapper/*.xml #在同一层目录下放映射文件
  type-aliases-package: com.atguigu.springcloud.entities    # 所有Entity别名类所在包

entities实体类

PaymentMain8001

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

entities.Payment

快速创建实体类

@Data 数据
@AllArgsConstructor 全参
@NoArgsConstructor 空参
public class Payment implements Serializable { 序列化 分布式部署可能用得上
    private Long id;
    private String serial;
}

entities.CommonResult

/**
 * 前后端分离-后端返回通用实体串
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommonResult <T>{//泛型 通用
    private Integer code; //数字类型的编码 404
    private String message;//消息类型
    private T data;//返回对应类的数据

    //定义一个不是全参和空参的构造器（因为data可能返回空）
    public CommonResult(Integer code, String message)
    {
        this(code,message,null);
    }

}

Dao

/**
 *Dao与数据库对接的
 *
 */
@Mapper
public interface PaymentDao
{
    //add save 新增(写操作)
    public int create(Payment payment);

    //读操作
    //@Param传入id参数 mybatis根据id查
    public Payment getPaymentById(@Param("id") Long id);
}

Mapper

忘了mybatis最重要的#和$的点下面大神写的看看

http://t.csdn.cn/qUE6G

PaymentMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.atguigu.springcloud.Dao.PaymentDao">
<!-- parameterType 返回一个Payment类  useGeneratedKeys返回一个数字 如果插入成功会大于0 主键是ID

resultMap 结果集映射 为了防止数据库里面各种大小写问题
column是数据库的 property是自己java写的 是为了防止下划线大小写问题


 INSERT INTO table_name (column1, column2, ...) VALUES (value1, value2, ...)-->
    <insert id="create" parameterType="Payment" useGeneratedKeys="true" keyProperty="id">
        insert into payment(serial) values(#{serial});
    </insert>

    <resultMap id="BashResultMap" type="com.atguigu.springcloud.entities.Payment">
        <id column="id" property="id" jdbcType="BIGINT"/>
        <id column="serial" property="serial" jdbcType="VARCHAR"/>
    </resultMap>
    <select id="getPaymentById" parameterType="Long" resultMap="BashResultMap">
        select * from payment where id = #{id};
    </select>
</mapper>

service

PaymentService

/**
 * 接口服务层
 */
public interface PaymentService {
        //add save 新增(写操作)
        public int create(Payment payment);

        //读操作
        //@Param传入id参数 mybatis根据id查
        public Payment getPaymentById(@Param("id") Long id);

}

PaymentServiceImpl

/**
 * 实现PaymentService
 */
@Service
public class PaymentServiceImpl implements PaymentService {

    @Autowired
    private PaymentDao paymentDao;

    public int create(Payment payment) {
        return paymentDao.create(payment);
    }

    //读操作
    //@Param传入id参数 mybatis根据id查
    public Payment getPaymentById(Long id) {
        return paymentDao.getPaymentById(id);
    }

}

controller

回忆前置知识

/**
 *支付控制器
 *
 * RestController的作用相当于Controller加ResponseBody共同作用的结果，但采用RestController请求方式一般会采用Restful风格的形式。
 *
 * Controller的作用：声明该类是Controller层的Bean，将该类声明进入Spring容器中进行管理
 *
 * ResponseBody的作用：表明该类的所有方法的返回值都直接进行提交而不经过视图解析器，且返回值的数据自动封装为json的数据格式
 *
 * RestController的作用：包含上面两个的作用，且支持Restful风格的数据提交方式
 *
 * Restful风格：
 * get:获取数据时用的请求方式
 * post：增加数据时的请求方式
 * put：更新数据时的请求方式
 * delete：删除数据时的请求方式

 @ResponseBody注解的作用是将controller的方法返回的对象 通过适当的转换器 
转换为指定的格式之后，写入到response对象的body区（响应体中），通常用来返回JSON数据或者是XML。
数据，需要注意的呢，在使用此注解之后不会再走视图处理器，而是直接将数据写入到输入流中，
它的效果等同于通过response对象输出指定格式的数据。

 这里还要着重强调一下，要通过@ResponseBody 注解 
将返回的json字符串放入响应体中，然后在前台js才能拿到json字符串进行解析，
如果不加，响应体中就没有放入json字符串，前台自然是拿不到数据的

 */

PaymentController

@RestController
@Slf4j
public class PaymentController
{

    @Resource//与Autowired一样
    private PaymentService paymentService;

    @PostMapping(value = "/payment/create")
    public CommonResult create(@RequestBody Payment payment)
    {
        //int是因为之前插入写了一个useGeneratedkeys 插入成功会>0
        int result = paymentService.create(payment);
        //企业一般用日志
        log.info("*****插入操作返回结果:" + result);

        if(result > 0)
        {
            return new CommonResult(200,"插入数据库成功",result);
        }else{
            return new CommonResult(444,"插入数据库失败",null);
        }
    }

    @GetMapping(value = "/payment/get/{id}")
    public CommonResult<Payment> getPaymentById(@PathVariable("id") Long id)
    {
        Payment payment = paymentService.getPaymentById(id);
        log.info("*****查询结果:{}",payment);
        if (payment != null) {
            return new CommonResult(200,"查询成功",payment);
        }else{
            return new CommonResult(444,"没有对应记录,查询ID: "+id,null);
        }
    }
}

回忆一下ResponseBody

http://www.java265.com/JavaFramework/Spring/202211/4947.html

测试

本人没下借用阳哥的图

postment模拟

测试的目的是为了

自测通过找出问题

热部署Devtools--仅限开发阶段发布要关闭热部署

如果代码改动时，希望可以让idea代码自动生效方便调试，不再自己关机启动了

Devtools

Adding devtools to your project

请粘贴到自己的项目里pom
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <scope>runtime</scope>
    <optional>true</optional>
</dependency>

Adding plugin to your pom.xml

父工程的pom
下段配置我们粘贴进聚合父类总工程的pom.xml里
 
<build>
    <finalName>你自己的工程名字</finalName>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <fork>true</fork>
                <addResources>true</addResources>
            </configuration>
        </plugin>
    </plugins>
</build>
 

例如我的

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <fork>true</fork>
                    <addResources>true</addResources>
                </configuration>
            </plugin>
        </plugins>
    </build>

Enabling automatic build

开启自动构建选项

Update the value of

我的好像已经自动部署了啊这不贴图了

重启IDEA

消费订单模块-80

pom 感觉以后都差不多一样了

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>cloud2023</artifactId>
        <groupId>com.atguigu.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-consumer-order80</artifactId>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

启动

@SpringBootApplication
public class OrderMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderMain80.class,args);
    }
}

yml

server:
  port: 80

接着是那些实体类就不写了

写重点

config


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

/**
 *RestTemplate
 * RestTemplate提供了多种便捷访问远程Http服务的方法，
 * 是一
 * 种简单便捷的访问restful服务模板类，是Spring提供的用于访问Rest服务的客户端模板工具集
 *
 * 使用
 * 使用restTemplate访问restful接口非常的简单粗暴无脑。
 * (url, requestMap, ResponseBean.class)这三个参数分别代表
 * REST请求地址、请求参数、HTTP响应转换被转换成的对象类型。
 */
@Configuration
public class ApplicationContextConfig
{
    @Bean
    public RestTemplate restTemplate()
    {
        return new RestTemplate();
    }
}

控制器

package com.atguigu.springcloud.Controller;

import com.atguigu.springcloud.entities.CommonResult;
import com.atguigu.springcloud.entities.Payment;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 *消费者控制器
 */
@RestController
@Slf4j
public class OrderController {
    public static final String PaymentSrv_URL = "http://localhost:8001";//地址

    @Autowired
    private RestTemplate restTemplate;

    //写用post postForObject
    @GetMapping("/consumer/payment/create") //客户端用浏览器是get请求，但是底层实质发送post调用服务端8001
    public CommonResult create(Payment payment)
    {
        return restTemplate.postForObject(PaymentSrv_URL + "/payment/create",payment,CommonResult.class);
    }


    //读用get getForObject
    @GetMapping("/consumer/payment/get/{id}")
    public CommonResult getPayment(@PathVariable Long id)
    {
        return restTemplate.getForObject(PaymentSrv_URL + "/payment/get/"+id, CommonResult.class, id);
    }
}

服务端一定要在控制器里写@RequestBody

要是不写客户端只能插入ID 插入不了数据