import com.alibaba.fastjson2.JSONObject;

import java.lang.reflect.Field;
import java.text.SimpleDateFormat;

public class JsonObjectUtlis {

    public static <U> JSONObject processEntityToJson(Class<U> clazz, U cla) {
        //将传过来的对象进行赋值处理，
        //此时u可用来代表传过来的对象（本示意中是Users）,
        //此时可以用u调用传过来对象的方法
        U u = clazz.cast(cla);
        //以下是验证此示意中实体类可被操作了
        //getDeclaredFields()：获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的申明字段。
        //.getClass()是一个对象实例的方法，只有对象实例才有这个方法，具体的类是没有的
        JSONObject jsonObject = new JSONObject();
        for (Field field : u.getClass().getDeclaredFields()) {
            //允许获取实体类private的参数信息 field.setAccessible(true);
            field.setAccessible(true);
            try {
                String name = field.getType().getName();
                if ("java.util.Date".equals(name) && field.get(u) != null) {
                    String dateStr = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(field.get(u));
                    if (dateStr.indexOf("00:00:00") > 0){
                        dateStr = dateStr.substring(0,10) ;
                    }
                    jsonObject.put(field.getName(), dateStr);
                }else {
                    jsonObject.put(field.getName(), field.get(u));
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
                jsonObject.put("convertJsonStatus",500);
                return jsonObject;
            }
        }
        return jsonObject;
    }
}

使用例子

        JSONObject jsonObject = JsonObjectUtlis.processEntityToJson(JudgeResultSynchronizationMatVO.class, synchronizationVO);
        // 第一个参数为对象的Clss类    第二个入参为实际对象

Json判断

判断当前字符串是不是Json字符串，是JSON返回True 否则返回false

public static boolean isjson(String str) {
        try {
            JSONObject jsonStr = JSONObject.parseObject(str);
            return  true;
        } catch (Exception e) {
            return false;
        }
}

准备一个阿里云的实名账号，自己直接注册就可以

阿里云官网：https://www.aliyun.com/

2. 配置步骤

1. 进入阿里云控制台

2. 在左上角的三条杠中点开找到容器

3. 这个就是配置地址

3. 使用配置镜像加速的命令去配置docker

1. 帮助启动相关

2. 镜像相关命令

1. docker images 查看本地的镜像

其中

• repository 表示镜像名称
• Tag 表示镜像的版本标签 同一个镜像可以有多个标签
• Image Id 表示镜像的ID
• Created 表示创建时间
• Size 表示文件大小

2. docker search <某个镜像的名称> 搜索镜像

其中

• Name 表示镜像的名称
• Description 表示镜像的说明
• stars 点赞的数量
• Officaial 表示是否是官方的 若是官方的 下方有一个[OK] 表示
• AutoMated 表示是否是自动构建的

Docker 自动构建镜像和非自动构建镜像的主要区别在于构建方式和更新机制。

自动构建镜像是通过与代码托管平台（如 GitHub、GitLab、Bitbucket 等）集成，当代码仓库中的代码发生变化时，Docker Hub 会自动触发构建过程，生成新的镜像。自动构建镜像的好处是可以自动化构建和更新镜像，减少手动操作，提高效率。但是，由于构建过程是自动化的，可能会导致构建失败或者镜像质量不稳定的问题。

非自动构建镜像则需要手动构建和更新，通常是通过 Dockerfile 文件来定义构建过程。这种方式可以更加灵活地控制构建过程和镜像内容，但需要手动操作，相对较为繁琐。

总的来说，自动构建镜像适用于需要频繁更新的应用，非自动构建镜像适用于需要更加精细控制的应用。

3. docker pull <某个镜像的名称> 下载/拉去镜像

### 4. docker system df 查看镜像/容器/数据卷占用的空间

5. docker rmi <某个镜像的名字> 删除镜像

其中删除全部中使用到的是Shell脚本的特性，支持了参数的续传，可以将docker images -qa查询到的所有的镜像的ID传输给docker rmi -f执行，即就可以删除全部

* Docker面试题：谈谈docker虚旋镜像是什么？

1. 虚旋镜像长什么样子？

在查询所有镜像仓库的时候可以看到的他 repository和TAG是< none >

## 3.容器相关的命令

1. 启动一个容器实例

如，要启动一个Nginx容器，并且取名为MyNginx，且让他后台运行，不占用前台命令行，就有如下命令行

docker run --name Mynginx -d nginx
## 
## 其中 --name 表示指定一个名称 后面是自定义的名称  
## -d 表示后台运行
## 最后是启动的这个镜像的名称

2. 查询当前正在运行的容器

其中

docker ps -q查询当前正在运行的容器的ID可以和其他命令参数进行组合使用，如我们要查询所有运行过的容器就可以有如下的代码

docker ps -aq

3. 退出当前容器

4. 启动/停止/强制停止的容器

5. 删除已经停止容器

在上面的例子中已经学到了删除镜像使用的命令是 docker rmi <镜像的ID>

在删除容器的时候，命令就是

docker rm <容器的ID>

# 强制删除容器 慎用 可以删除正在运行的容器 
dcker rm -f <容器的ID>

注意: 容器保护机制让docker 只可以删除已经停止的镜像

6. 查看容器启动的日志

4. 交互式启动

1. 什么是交互式启动？

交互式启动如字面意思，有交互的启动，具体理解起来可以有如下例子：

现在我们在docker 中创建了一个ubantu容器，因为Ubantu是Linux系统，这个Linux系统是有交互的，我们启动的时候可以使用如下命令docker run -it -name linux1 ubuntu 我们可以直接进入到这个系统中，并产生了一个交互式控制台输入，这个时候可以调用我们的linux命令进行操作这个容器，这就是交互

思考？

若我们退出的时候，应该如何再次进入，并产生交互控制台呢？

这个时候就使用到了交互式启动运行

1. 环境配置

• SpringBoot 2.7.11
• Maven 3.6.1

2. 依赖包

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

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


        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.1</version>
        </dependency>


        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>


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


        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

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


        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.16</version>
        </dependency>

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

3. 数据库配置

CREATE DATABASE /*!32312 IF NOT EXISTS*/`school_secrity` /*!40100 DEFAULT CHARACTER SET utf8mb4 */;

USE `school_secrity`;

/*Table structure for table `user` */

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户ID',
  `username` varchar(20) NOT NULL COMMENT '用户名',
  `password` varchar(512) NOT NULL COMMENT '用户密码',
  `roler` char(2) NOT NULL DEFAULT '0' COMMENT '0 普通用户',
  `isDelete` char(1) DEFAULT '0' COMMENT '0 存在 1删除',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4;

4. SpringBoot配置文件

server:
  port: 8080
  servlet:
    context-path: /
# mybatis plus配置
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl  # 日志输出
  global-config:
    db-config:
      logic-delete-field: isDelete # 逻辑删除 需要加一个注解 @TableLogic
      logic-not-delete-value: 0 # 未删除逻辑值
      logic-delete-value: 1 # 已经删除逻辑值
# spring 配置
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver # 数据库连接驱动
    url: jdbc:mysql://localhost:3306/school_secrity # 数据库Url
    username: root # 数据库账号
    password: 123456 # 数据库密码
  thymeleaf:
    cache: false # 不使用缓存

  redis:
    host: 192.168.244.128
    port: 6379

5. 认证流程

1. 使用之前的配置

若不理解 JWT是什么可以先去了解下 JWT是什么再来看本篇文章

在使用之前，首先要关闭 spring security 默认的登录页面

因为是前后端分离，我们就可以不使用session域进行存储用户的登录态，这里使用的 JWT认证登录态

因为是前后端分离，所以我们就可以在登录成功之后使用 JWT给用户返回一个登录的令牌，来认证登录信息

然后我们要指定我们自己的登录接口，和使用spring security自带的一个密码加密对象所以就有了如下的配置文件

@Configuration
public class SecrityConfig extends WebSecurityConfigurerAdapter {
    
    /**
     * 密码加密对象
     *
     * @return
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    
    /**
     * 前后端分离项目,配置不使用Session 和 关闭 csrf 和 指定登录接口
     * @param http
     * @throws Exception
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable() // 关闭scrf
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)// 不使用Session
                .and()
                .authorizeRequests()
                .antMatchers("/user/login").anonymous() // 登录接口可以匿名访问
                .anyRequest().authenticated(); // 其他接口必须已经登录


        // 配置认证过滤器 在这里可以先忽略这个
        // http.addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);
    }


    @Bean
    @Override  // 身份验证管理器
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

2. 编写认证实体类

在spring security中认证有专门的实体类封装数据，所以我们需要将实体类编写，这里需要实现接口UserDetails即有了如下实体类

/**
 * 创建用户登录的对象
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginUser implements UserDetails {
    
    /**
     * 登录的用户对象
     * 将我们自己编写的表对象实体注入到里面
     */
    private User user;

    /**
     * 权限列表，这里认证流程可以忽略
     * @return
     */
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return null;
    }

    /**
     * 获取密码
     * @return
     */
    @Override
    public String getPassword() {
        return user.getPassword();
    }

    /**
     * 获取用户名
     * @return
     */
    @Override
    public String getUsername() {
        return user.getUsername();
    }

    /**
     * 账户是未过期的
     * @return
     */
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    /**
     * 账户是未被锁定的
     * @return
     */
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    /**
     * 凭据是未过期的
     * @return
     */
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    /**
     * 账户已启用的
     * @return
     */
    @Override
    public boolean isEnabled() {
        return true;
    }
}

3. 使用MybatisPlus生成Service和Mapper和表实体类

这里忽略不讲，使用逆向工程生成，或使用插件生成，或自己编写都可以

4.重写默认登录接口

在SpriingSecurity中有一个默认的登录接口，使用的是他自己的用户名和密码，我们需要重写，编程查询数据库得到用户名和密码

所以我们的Service层或单独的一个登录接口中要实现接口UserDetailsService

这里使用的是MybatisPlus生成的Service,在生成的Service中又实现了接口UserDetailsService 可以根据自己的习惯进行更改

所以就有了如下实现类

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User>
    implements UserService, UserDetailsService {
    /**
     * 重写登录接口
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        System.out.println("执行重写登录接口");
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(User::getUsername,username);
        // 数据库查询用户对象
        User user = baseMapper.selectOne(wrapper);

        if (Objects.isNull(user)){
            throw new RuntimeException("用户名或者密码错误");
        }
        
        return new LoginUser(user);
    }
}

5. 编写自己的Controller和Service业务层

我们在SecrityConfig配置文件中声明了自己的Controller接口请求URL/user/login 所以我们在定义的时候也要写这样的URL，所以有了

如下的Controller类

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping("/login")
    public Result login(@RequestBody User user){
        Result login = userService.login(user);
        return login;
    }
}

Service层中添加代码

在接口中需要自己添加此方法的接口

    @Override
    public Result login(User user) {
        System.out.println("进入Login");
        // 将前端传输过来的用户对象封装成Springsecurity可以使用的对象
        UsernamePasswordAuthenticationToken authenticationToken =
                new UsernamePasswordAuthenticationToken(user.getUsername(),user.getPassword());
        
        // 认证管理器，在配置文件中注释掉了，可以放开，并且添加
        Authentication authenticate = null;
        try {
            authenticate = authenticationManager.authenticate(authenticationToken);
        }catch (Exception e){
            String message = e.getMessage();
            System.out.println("message = " + message);
        }


        System.out.println("authenticate = " + authenticate);
        if (Objects.isNull(authenticate)){
            throw new RuntimeException("用户名或者密码错误");
        }
        // 通过DeBug看 authenticate.getPrincipal(); 本质就是我们重写之后的LoginUser类对象，所以可以强转
        System.out.println("认证通过");
        LoginUser principal = (LoginUser) authenticate.getPrincipal();
        Map<String, Object> map = new HashMap<>();
        map.put("id",principal.getUser().getId());
        // 生成用户的JWT token
        String jwtToken = JWTUtils.getJwtToken(map);
        map.clear();
        map.put("token",jwtToken);
        return new Result(200,"成功",map);
    }

6.注意事项

其中我们要注意我们的密码加密对象passwordEncoder

在此框架中，我们只需要将此对象注入即可以实现在密码校验上的自动校验，但是在密码存储时，需要我们自己调用encoder方法进行加密后存储

7. 认证过滤器

我们的登录接口是被配置文件放行的，所以我们可以直接访问，直接进入登录接口进行登录，若我们想要使用JWT生成的令牌进行登录态验证，我们就需要配置一个认证的过滤器，这个过滤器是在每次调用service层前执行的，所以就可以对我们每次请求过来的令牌进行认证，用户是否登录

所以就有如下Java代码

/**
 * JWT过滤器
 */
@Component
public class JwtFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
         // 从请求头中获取token
        String token = request.getHeader("token");
        if (Strings.hasText(token)){
            try {
                Jws<Claims> claimsJws = JWTUtils.parseJwtToken(token);
                Object id = claimsJws.getBody().get("id");
                System.out.println("用户的id = " + id);
                // 通过用户ID去redis缓存中拿用户的信息

                // 若用户不存在，那么是未登录 存在则已经登录

                // 封装用户信息
                UsernamePasswordAuthenticationToken authenticationToken
                        = new UsernamePasswordAuthenticationToken("admin","123456",null);
                // 其中这里的admin 123456 是需要从redis中获取到的数据装进去的并不是固定的
                // 放入上下文对象
                SecurityContextHolder.getContext().setAuthentication(authenticationToken);

            } catch (SignatureException e) {
                e.printStackTrace();
            }
        }
        // 放行
        filterChain.doFilter(request,response);
    }
}

OncePerRequestFilter 我们实现这个接口之后，这个过滤器是只被执行一次的，因为过滤器在特殊情况下，是可能执行多次的

6. 认证代码执行顺序

1. 前端请求控制器，因有过滤器的缘故，会直接进入过滤器
2. 进入过滤器，因我们是登录接口，是没有token信息的，那么我们在过滤器中判断没有取到token将直接放行请求去service层登录
3. 接下来会正式进入controller中，执行我们的代码逻辑，从controller中执行到我们的service层
4. 进入service层，会调用我们自己的login方法，然后方法中会将我们的前端传输过来的用户对象封装成spring security可以识别的用户对象
5. 然后使用我们的认证管理器对象，进行认证管理，没有抛出异常证明认证没有错误，我们需要调用认真管理器对象中的方法获取到我们的认证对象的信息
6. 接下来就是判断对象是否为null 然后对我们的对象进行简单的封装，使用 JWT生成令牌并且返回
7. 在之后的每次请求中需要带入令牌进行请求

7. 用户授权

首选需要在登录的基础上进行授权，授权目的是判断用户是否有权限进行操作这个接口，或是否有权限进行这个操作

在上面的基础上我们在SecurityConfig配置文件中的类上加上注解，开启注解方式的授权

@EnableGlobalMethodSecurity(prePostEnabled = true)//开启注解形式的授权功能

1. 简单的实现授权

在controller中新创建一个test的控制器，有如下代码

    @RequestMapping("/test")
    @PreAuthorize("hasAnyAuthority('user')") // 判断当前是否有user权限
    public Object test(){
        return "123123123";
    }

我们去调用这个方法，并且带入我们的token会提示我们没有权限，那么我们就实现了一个简单的权限添加

接下来是如何给用户添加权限

2. 给用户添加权限

我们在编写用户登录的实体类中，我们有一个获取用户权限的方法getAuthorities，所以我们要使用这个方法，将用户的权限封装到这里，即就可以更改LoginUser对象，加入一个属性

    /**
     * 用户的权限集合
     */
    private Set<String> set;
    //LoginUserDetails要被存储到redis 但redis要求使用的数据必须序列化 但SimpleGrantedAuthority类型不是序列化
    //需要忽略此属性
    @JSONField(serialize = false)
    private List<SimpleGrantedAuthority> authorities; // 用于封装
     // 构造方法需要写一个不带authorities 只有 set 和 user 两个对象的构造
    public LoginUser(User user, Set<String> set) {
        this.user = user;
        this.set = set;
    }

3. 封装权限获取方法

    /**
     * @return
     */
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        if (list!=null){
            return list;
        }
        list = new ArrayList<>();
        for (String s : set) {
            list.add(new SimpleGrantedAuthority(s));
        }
        return list;
    }

4. 修改过滤器中代码

我们将对象中添加的权限信息，那么在每次请求非登录接口时都需要带上我们的权限，让我们的权限认证系统去认证是否有权限继续执行

那么将在过滤器中修改如下代码

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        log.info("进入过滤器");
        // 从请求头中获取token
        String token = request.getHeader("token");
        if (Strings.hasText(token)){
            try {
                Jws<Claims> claimsJws = JWTUtils.parseJwtToken(token);
                Object id = claimsJws.getBody().get("id");
                System.out.println("用户的id = " + id);
                // 通过用户ID去redis缓存中拿用户的信息

                // 若用户不存在，那么是未登录 存在则已经登录

                // 封装用户信息
                // 获取用户权限信息，这里需要查询数据库获取
                ArrayList<SimpleGrantedAuthority> list = new ArrayList<>();
                list.add(new SimpleGrantedAuthority("test"));
                list.add(new SimpleGrantedAuthority("user"));
                UsernamePasswordAuthenticationToken authenticationToken
                        = new UsernamePasswordAuthenticationToken("admin","123456",list);
                // 放入上下文对象
                SecurityContextHolder.getContext().setAuthentication(authenticationToken);

            } catch (SignatureException e) {
                e.printStackTrace();
            }
        }
        // 放行
        filterChain.doFilter(request,response);
    }

8. 自定义异常处理

1. 认证失败处理器

/**
 * 认证失败异常处理
 */
@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse
            response, AuthenticationException authException) throws IOException,
            ServletException {
        Result result= new Result(401, "用户认证失败！", null);
        response.getWriter().println(result);
    }
}

2. 授权失败处理器

/**
 * 授权失败异常处理
 */
@Component
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        Result result = new Result(400, "授权失败", null);
        response.getWriter().println(result);
    }
}

3. 更改配置类

在上面两个异常处理器处理完成后我们需要将异常处理类的对象注入到security的配置文件中，然后就配置完成了

@Autowired
private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
@Autowired
private AuthenticationEntryPointImpl authenticationEntryPointImpl;

//配置异常处理器 这段代码在configure方法中定义
http.exceptionHandling()
.authenticationEntryPoint(authenticationEntryPointImpl)//认证
.accessDeniedHandler(accessDeniedHandlerImpl);//授权

9. 配置跨域设置

配置类

@Configuration
public class CorsConfig implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
            //设置允许跨域的路径
        registry.addMapping("/**")
                .allowedOriginPatterns("*")//允许跨域的域名
                .allowCredentials(true)//允许携带cookie
                .allowedMethods("GET","DELETE","PUT","POST")//跨域的请求方式
                .allowedHeaders("*")//允许的header属性
                .maxAge(3600);//跨域时间
    }
}

然后在security中开启跨域，只需要在configure方法中添加如下代码

//springsecrity开启允许跨域
    http.cors();

Spring Boot是由Pivotal团队提供的一套开源框架，可以简化spring应用的创建及部署。它提供了丰富的Spring模块化支持，可以帮助开发者更轻松快捷地构建出企业级应用。Spring Boot通过自动配置功能，降低了复杂性，同时支持基于JVM的多种开源框架，可以缩短开发时间，使开发更加简单和高效。（SpringBoot简化开发，可以快速部署SSM项目，整合了很多个配置，使用的时候只需要加上 Jar 包和对应的配置注解即可实现配置，Springboot内置了Tomcat）

1. 构建SpringBoot项目

这里使用的IDEA编辑器，每个编辑器的构建方式可能有些不同，但是大致相同，使用别的编辑器的同学可以拿这篇文章作为参考

方式一：使用官网构建

使用官网页面，直接下载springboot项目，使用流程如下

官网： https://start.spring.io/

方式二：使用IDEA构建

在IDEA中点击new project 创建新项目，然后根据需求构建项目

注意：

​ 使用此方法构建的SpringBoot和方式一构建的方式不同点在于一个是下载了一个压缩包文件，一个是直接在IDEA开发工具中下载，区别不大

方式三：自己配置

自己配置SpringBoot对于新手来说不太友好，要求对Jar包的熟悉程度比较高，个人不太推荐，大佬忽略，这里没有具体的配置方式

配置方式：

​ 使用IDEA工具构建一个新的Maven工程，然后在POM文件中添加SpringBoot的相关依赖，自己创建Application启动类和配置文件

注意：
    Mybatis-Plus不可以直接勾选Jar包进行依赖引入，需要我们自己去官网选择版本引入

目录结构

2. SpringBoot核心配置

SpringBoot有两种配置文件结尾，application.properties application.yml

yml 是一种 yaml 格式的配置文件，主要采用一定的空格、换行等格式排版进行配置。

yaml 是一种直观的能够被计算机识别的的数据序列化格式，容易被人类阅读，yaml 类似于 xml，但是语法比 xml 简洁很多，值与前面的冒号配置项必须要有一个空格， yml 后缀也可以使用 yaml 后缀。

注意：

​ SpringBoot项目的配置文件必须使用application名称，否则不识别

1. SpringBoot基本配置

# SpringBoot的核心配置文件
server:
  port: 8080  # 指定项目运行的端口
  servlet:
    context-path: /  # 指定项目的运行路径
    encoding:
      charset: utf-8 # 指定项目的编码集
spring:
  profiles:
    active: dev # 多环境下使用的环境是哪个，不写就默认 application

2. 多环境配置

在实际开发的过程中，我们的项目会经历很多的阶段（开发->测试->上线），每个阶段的配置也会不 同，例如：端口、上下文根、数据库等，那么这个时候为了方便在不同的环境之间切换，SpringBoot 提供了多环境配置

为每个环境创建一个配置文件，命名必须以 application-环境标识.properties|yml

例如：

1. application-dev.yml
2. application-test.yml

3. 自定义配置

SpringBoot 的核心配置文件中，除了使用内置的配置项之外，我们还可以在自定义配置，然后采用注解去读取配置的属性值

如：

​ 在application.yml配置文件中有如下配置

school:
  name: 清华大学
  address: 北京

那么我们就可以在项目中使用

    @Value("${school.name}") // 注入属性
    private String schoolName; 

3. SpringBoot事务管理

Spring Boot 使用事务非常简单，底层依然采用的是 Spring 本身提供的事务管理

在入口类中使用注解 @EnableTransactionManagement 开启事务支持

在访问数据库的 Service 方法上添加注解 @Transactional 即可

4. SpringBoot整合mybatisPlus、thymeleaf、druid、redis、Dubbo配置

# SpringBoot的核心配置文件
server:
  port: 8080  # 指定项目运行的端口
  servlet:
    context-path: /  # 指定项目的运行路径
    encoding:
      charset: UTF-8 # 指定项目的编码集
      enabled: true # 开启为 true
      force: true # 强制使用

# Spring 配置
spring:
  application:
    name: demo # spring项目名称
  profiles:
    active: dev # 使用的环境是哪个
  thymeleaf:
    cache: false # thymeleaf 不使用缓存
  datasource: # 数据库连接配置
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/ssm
    type: com.alibaba.druid.pool.DruidDataSource # 使用的数据库连接池需要导入 jar 包 druid-spring-boot-starter
    druid: # 可以不配置，有默认值
      initial-size: 5 # 初始化连接数
      min-idle: 5 # 最小连接数
      max-active: 20 # 最大连接数
      max-wait: 60000 # 获取数据库连接最大等待时间 单位毫秒
      time-between-eviction-runs-millis: 60000 # 配置多久进行一次检测，检测需要关闭的空闲连接 单位毫秒
  redis:  # redis 配置
    host: localhost
    port: 6379
#    password:  # redis密码，没有注释掉

# mybatis-plus 配置
mybatis-plus:
  mapper-locations: classpath*:/mapper/**/*.xml # 默认值，扫描mapper.xml文件
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl  # 日志输出
  global-config:
    db-config:
      logic-delete-field: isDelete # 逻辑删除 需要加一个注解 @TableLogic
      logic-not-delete-value: 0 # 未删除逻辑值
      logic-delete-value: 1 # 已经删除逻辑值

# Dubbo服务提供者
#dubbo:
#  application:
#    name: provide
#  registry:
#    address: zookeeper://localhost:2181
#  scan:
#    base-packages: com.dyf # 这里配置Dubbo的注解所在包,扫描的是接口实现类


# Dubbo消费者
#dubbo:
#  application:
#    name: cosumer
#  registry:
#    address: zookeeper://localhost:2181
#  scan:
#    base-packages: com.dyf # 这里配置Dubbo的注解所在包,扫描的是controller

5. SpringBoot整合MybatisPlus分页插件配置类

@Configuration
public class MyBatisPlusConfig {
    /**
     * 新的分页插件,一缓和二缓遵循mybatis的规则,需要设置 MybatisConfiguration#useDeprecatedExecutor = false 避免缓存出现问题(该属性会在旧插件移除后一同移除)
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 这里需要指定数据库类型 这里使用的Mysql
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

6. 整合所需要的 jar 包

导入SpringBoot 父类项目

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.11</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

导入所需要的 Jar 包

    <dependencies>
        <!--redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--springboot Web包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--springBoot 测试包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--Druid 数据库连接池包-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.16</version>
        </dependency>
        <!--mybatisPlus包-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.1</version>
        </dependency>
        <!--redis Jar包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!--Dubbo Jar包-->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.8</version>
        </dependency>
        <!--zookeep包，注册中心，整合Dubbo时候使用-->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-dependencies-zookeeper</artifactId>
            <version>2.7.8</version>
            <type>pom</type>
            <!--取消引入这两个日志框架，若引入控制台会报错，Jar重复引入-->
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-reload4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

1. 在我们设计接口的时候，通常情况下会将注释一并加上去，但是我们的接口中的注释往往不会跟着我们的接口实现而重写过来，每次都需要拷贝，非常麻烦，接下来就是一个如何设置IDEA将注释也一并重写过来

2. 设置方式

1. 现有接口

2. 在实现类中重写

只需要勾选重写窗口中的 Copy JavaDoc 即可

注意：

​ 单行注释和多行注释都不支持被重写，只支持文档注释，下面会介绍Java中的注释

3. Java中的注释

1. 普通注释

普通注释的注释方法 //

如：

普通注释只可以注释单行内容

2. 多行注释

多行注释可以注释多行内容，需要在注释的范围内，不可以超越范围

3. 文档注释

文档注释也可以多行，文档注释加在方法上面可以生成一些方法上面的内容，如参数 和返回值，并且支持被重写复制到实现类上

如何快捷生成：

在IDEA中（其他工具方法可能不同），在方法上面输入 /** 然后按一下回车就可以生成了

1. 创建数据库

-- 创建数据库
create database [数据库名称] charset=utf8;
-- 使用数据库
use database [数据库名称];

2. 创建民族表

create table [表名称](
    `id` varchar(32) primary key comment '民族id',
    `nation` varchar(64) comment '民族名称'
);

3. 添加民族数据

INSERT INTO `[表名称]` VALUES ('1', '汉族');
INSERT INTO `[表名称]` VALUES ('2', '蒙古族');
INSERT INTO `[表名称]` VALUES ('3', '回族');
INSERT INTO `[表名称]` VALUES ('4', '藏族');
INSERT INTO `[表名称]` VALUES ('5', '维吾尔族');
INSERT INTO `[表名称]` VALUES ('6', '苗族');
INSERT INTO `[表名称]` VALUES ('7', '彝族');
INSERT INTO `[表名称]` VALUES ('8', '壮族');
INSERT INTO `[表名称]` VALUES ('9', '布依族');
INSERT INTO `[表名称]` VALUES ('10', '朝鲜族');
INSERT INTO `[表名称]` VALUES ('11', '满族');
INSERT INTO `[表名称]` VALUES ('12', '侗族');
INSERT INTO `[表名称]` VALUES ('13', '瑶族');
INSERT INTO `[表名称]` VALUES ('14', '白族');
INSERT INTO `[表名称]` VALUES ('15', '土家族');
INSERT INTO `[表名称]` VALUES ('16', '哈尼族');
INSERT INTO `[表名称]` VALUES ('17', '哈萨克族');
INSERT INTO `[表名称]` VALUES ('18', '傣族');
INSERT INTO `[表名称]` VALUES ('19', '黎族');
INSERT INTO `[表名称]` VALUES ('20', '傈僳族');
INSERT INTO `[表名称]` VALUES ('21', '佤族');
INSERT INTO `[表名称]` VALUES ('22', '畲族');
INSERT INTO `[表名称]` VALUES ('23', '高山族');
INSERT INTO `[表名称]` VALUES ('24', '拉祜族');
INSERT INTO `[表名称]` VALUES ('25', '水族');
INSERT INTO `[表名称]` VALUES ('26', '东乡族');
INSERT INTO `[表名称]` VALUES ('27', '纳西族');
INSERT INTO `[表名称]` VALUES ('28', '景颇族');
INSERT INTO `[表名称]` VALUES ('29', '柯尔克孜族');
INSERT INTO `[表名称]` VALUES ('30', '土族');
INSERT INTO `[表名称]` VALUES ('31', '达翰尔族');
INSERT INTO `[表名称]` VALUES ('32', '么佬族');
INSERT INTO `[表名称]` VALUES ('33', '羌族');
INSERT INTO `[表名称]` VALUES ('34', '布朗族');
INSERT INTO `[表名称]` VALUES ('35', '撒拉族');
INSERT INTO `[表名称]` VALUES ('36', '毛南族');
INSERT INTO `[表名称]` VALUES ('37', '仡佬族');
INSERT INTO `[表名称]` VALUES ('38', '锡伯族');
INSERT INTO `[表名称]` VALUES ('39', '阿昌族');
INSERT INTO `[表名称]` VALUES ('40', '普米族');
INSERT INTO `[表名称]` VALUES ('41', '塔吉克族');
INSERT INTO `[表名称]` VALUES ('42', '怒族');
INSERT INTO `[表名称]` VALUES ('43', '乌孜别克族');
INSERT INTO `[表名称]` VALUES ('44', '俄罗斯族');
INSERT INTO `[表名称]` VALUES ('45', '鄂温克族');
INSERT INTO `[表名称]` VALUES ('46', '德昂族');
INSERT INTO `[表名称]` VALUES ('47', '保安族');
INSERT INTO `[表名称]` VALUES ('48', '裕固族');
INSERT INTO `[表名称]` VALUES ('49', '京族');
INSERT INTO `[表名称]` VALUES ('50', '塔塔尔族');
INSERT INTO `[表名称]` VALUES ('51', '独龙族');
INSERT INTO `[表名称]` VALUES ('52', '鄂伦春族');
INSERT INTO `[表名称]` VALUES ('53', '赫哲族');
INSERT INTO `[表名称]` VALUES ('54', '门巴族');
INSERT INTO `[表名称]` VALUES ('55', '珞巴族');
INSERT INTO `[表名称]` VALUES ('56', '基诺族');

4. 使用技巧

将添加的数据的语句复制到记事本中，使用记事本中的替换功能进行替换

快捷键：Ctrl + h

然后在数据库中执行SQL语句即可完成

1. 导入Maven坐标

  <dependency>
        <groupId>javax.mail</groupId>
        <artifactId>mail</artifactId>
        <version>1.4.7</version>
    </dependency>

2. 创建Java发送邮件工具类

/**
 * 发送邮件工具类
 */
public class SendEmailUtils {
    
    private String user; // 发件人称号，同邮箱地址
    private String password; // 如果是qq邮箱可以使户端授权码，或者登录密码
    private String host;    // 指定发送邮件的主机QQ为 smtp.qq.com

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    /**
     * 创建邮件发送的对象
     *
     * @param USER     发件人称号，同邮箱地址
     * @param PASSWORD 如果是qq邮箱可以使户端授权码，或者登录密码
     * @param HOST     指定发送邮件的主机QQ为 smtp.qq.com
     */
    public SendEmailUtils(String USER, String PASSWORD, String HOST) {
        this.user = USER;
        this.password = PASSWORD;
        this.host = HOST;
    }

    /**
     * 发送邮件 支持HTML标签
     * @param toEmail 邮件接收方的邮箱
     * @param headText 邮件的头部主题信息
     * @param bodyText 邮件的主体部分实质内容
     * @return 成功返回true 失败返回false
     */
    public boolean send(String toEmail, String headText, String bodyText) {
        // 获取系统属性
        Properties properties = System.getProperties();
        // 设置邮件服务器
        properties.setProperty("mail.smtp.host", getHost());
        properties.put("mail.smtp.auth", "true");
        // 获取默认session对象
        Session session = Session.getDefaultInstance(properties, new Authenticator() {
            public PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication(getUser(), getPassword()); //发件人邮件用户名、授权码
            }
        });
        boolean success = true;
        try {
            // 创建默认的 MimeMessage 对象
            MimeMessage message = new MimeMessage(session);

            // Set From: 头部头字段
            message.setFrom(new InternetAddress(user));

            // Set To: 头部头字段
            message.addRecipient(Message.RecipientType.TO,
                    new InternetAddress(toEmail));

            // Set Subject: 头部头字段
            message.setSubject(headText);

            // 设置邮件的内容体
            message.setContent(bodyText, "text/html;charset=UTF-8");

            // 发送消息
            Transport.send(message);

        } catch (MessagingException mex) {
            success =false;
            mex.printStackTrace();
        }

        return success;

    }
}

3. 使用Java工具类

1. QQ邮箱授权码需要在QQ邮箱中获取
2. 别的邮箱的授权码可以百度搜索在哪里获取，一般情况下QQ使用的比较多

    public static void main(String[] args) {
        String user = "xxx@qq.com"; // 发件人称号，同邮箱地址
        String password = "邮箱授权码"; // 如果是qq邮箱可以使户端授权码，或者登录密码
        String host = "smtp.qq.com";    // 指定发送邮件的主机QQ为 smtp.qq.com
        SendEmailUtils sendEmailUtils = new SendEmailUtils(user,password,host);
        String toEmail="xxx@qq.com";
        String head="头信息";
        String body="<h1>主题信息</h1>";
        boolean send = sendEmailUtils.send(toEmail, head, body);
        System.out.println("send = " + send);
    }

这个实体类是可以更变的，具体的实体类可以根据自己的业务需求去编写，这里使用的是一个比较通用一点的实体类来接收，也可以不使用实体类接收，直接使用，不过在日常开发中，不建议这样去做

• 创建实体，并生成他的 Get 和 Set 方法，有参数构造和无参数构造

public class VerifyCode {
    private String code;   // 验证码文字信息
    private BufferedImage imgs; // 图片验证码信息
}

2. 验证码工具类

import java.awt.*;
import java.awt.image.BufferedImage;
import java.util.Random;

/**
 * 获取验证码
 */
public class VerifyCodeUtils {

    private int height = 30;  // 图片宽

    private int width = 80;   // 图片高

    private int codeNumber = 4; // 生成的验证码个数

    // 定义有哪些字符验证码
    private String codeString = "23456789abcdefghjkmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZ";
    // 定义背景颜色
    private Color backgroundColor = new Color(255, 255, 255);

    // 定义字体
    private String[] fontNames = { "宋体", "华文楷体", "黑体", "微软雅黑", "楷体_GB2312"};

    // 获取一个验证码，用来生成图片
    public String getCodeText(){
        StringBuffer codeText = new StringBuffer();
        for (int i = 0; i < codeNumber; i++) {
            int randomNumber = getRandomNumber(1,codeString.length());
            codeText.append(codeString.charAt(randomNumber));
        }
        return  codeText.toString();
    }
    // 获取一个随机数字，用来取得codeString中的随机一个字母
    public int getRandomNumber(int start,int end){
        int randomNumber = (int) (Math.random() * (end-start)+start);
        return randomNumber;
    }

    // 生成一个随机颜色
    public Color getRandomColor(){
        int r = getRandomNumber(1,255);
        int g = getRandomNumber(1,255);
        int b = getRandomNumber(1,255);
        Color color = new Color(r,g,b);
        return color;
    }
    // 生成一个随机字体
    public Font getRandomFont(){
        // 字体 如黑体
        String fontStyle = fontNames[getRandomNumber(0,fontNames.length)];
        //  字体加粗斜体 Font.BOLD = 1     Font.ITALIC = 2     Font.BOLD + Font.ITALIC = 3
        int fontBlod = getRandomNumber(1,4);
        // 定义字体大小
        int size = getRandomNumber(24,30);
//        System.out.println("字体：" + fontStyle + "   加粗：" + fontBlod + "   字体大小：" + size);
        Font font = new Font(fontStyle,fontBlod,size);
        return font;
    }

    // 获取图片验证码
    public VerifyCode getCodeImge(){
        // 创建一个验证码的实体
        VerifyCode verifyCode = new VerifyCode();
        // 创建画板  不带透明色的画板
        BufferedImage bufferedImage = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
        // 获取此画板的画笔
        Graphics graphics = bufferedImage.getGraphics();
        // 设置画笔的颜色
        graphics.setColor(backgroundColor);
        // 填充画板背景颜色
        graphics.fillRect(0,0,width,height);
        // 获取随机验证码文字
        String codeText = getCodeText();
        // 在画板上画出验证码
        for (int i = 0; i < codeNumber; i++) {
            // 给画笔设置一个随机颜色
            graphics.setColor(getRandomColor());
            // 设置一个随机颜色
            graphics.setFont(getRandomFont());
            // 设置验证码的X坐标 当前是第几个字符转为float 乘以画板大小，除以验证码个数等于平均每个验证码的位置
            float x = i*1.0f*width/codeNumber;
            int y = height - getRandomNumber(8,height-(8*2));
            // 将验证码逐个写到图片上
            graphics.drawString(codeText.charAt(i)+"", (int) x,y);
        }
        // 在实体中添加验证码的信息
        verifyCode.setCode(codeText);
        verifyCode.setImgs(bufferedImage);
        return verifyCode;
    }
}

3. 使用验证码工具类

• 这个代码是JavaServlet中的一个请求，是最基础的web请求和响应方式，在使用中可以根据自己的实际使用场景去使用，这里只做了一个大概的演示

/**
 * 获取验证码
 */
// 注解servlet注册
@WebServlet("/getVerify")
public class VerifyCodeServlet extends ServletUtils {
    // 这里的servlet Utils和继承HttpServlet中的doGet和doPost方法一致
    public void getVerify(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 创建工具类对象
        VerifyCodeUtils verifyCodeUtils = new VerifyCodeUtils();
        // 获取验证码，返回实体对象
        VerifyCode codeImge = verifyCodeUtils.getCodeImge();
        // 查询验证码是什么
        System.out.println("验证码：" + codeImge.getCode());
        // 在session域中放入验证码
        req.getSession().setAttribute("registerVerifyCode",codeImge.getCode());
        // 将图片写到页面上
        ImageIO.write(codeImge.getImgs(),"png",resp.getOutputStream());
    }
}

1. 软件安装

官网： Git - 安装 Git (git-scm.com)

下载地址： https://git-scm.com/download/win

2.设置用户名

设置用户名

git config --global user.name "XXX" # 设置用户名
git config --global user.email "xxx" # 设置邮箱

查看设置的用户名

git config --global user.name
git config --global user.email

3. 设置常用命令的别名

1. 打开用户目录，创建.bashrc文件，可以使用命令窗口创建，命令如下：

touch ~/.bashrc

2. 编辑文件内容

# 用于输出git提交日志
alias git-log='git log --pretty=oneline --all --graph --abbrev-commit'
#用于输出当前目录所有文件及基本信息
alias ll='ls -al'

3. 使用配置文件，让配置文件生效

source ~/.bashrc

二、基本使用

要使用Git对我们的代码进行版本控制，首先需要获得本地仓库

创建本地仓库

本地仓库可以是任何一个文件夹，都可以是一个本地仓库，可以对这个仓库的文件进行版本控制和内容管理

1. 初始化

直接在文件夹中打开Git命令管理时此时文件夹并不是一个本地仓库，需要对此文件夹进行初始化，在初始化之后，这个文件夹就变成了本地仓库，就可以使用命令进行管理和控制文件了

# 仓库初始化
git init

2. 基础操作命令

Git在工作目录下，对于文件的修改会存在下面几个状态，这些状态会随着Git的命令而发生变化

2.0 Git管理的仓库文件状态分类

• 当我们在仓库中创建一个文件的时候，此时文件为：未跟踪状态，这个状态下的文件不在本地仓库，不在Git所管理的范围中
• 当我们调用 git add (需要选择哪些文件 . 表示所有修改的文件)这个命令之后，这些文件会被放入到Git的暂存区
• 当我们调用git commit这个命令之后，被放入暂存区的文件会被提交到本地仓库，此时这些文件就会被git所管理，就可以进行版本控制了

2.1 查看当前仓库文件状态

# 这个命令可以查询到当前仓库的文件状态（暂存区 / 工作区 / 已提交）
git status

2.2 将文件从工作区添加到暂存区

 # 这个命令会将指定文件名称的文件放入到暂存区
 git add <文件名称>

# 这个命令会将所有的已修改的文件放入到暂存区
git add .

2.3 将文件从暂存区放入到本地仓库管理

# 这个命令会将在暂存区存储的文件放入到本地仓库
git commit -m "XXXX(这个地方是修改的日志)"

2.4 查看提交日志

• 若配置了别名，可以使用 git -log 就包含了下面这些参数

git log -all # 显示所有的分支
git log -pretty=oneline # 将提交的信息显示到一行
git log -abbrev-commit # 使得输出的commitId更简短
git log graph # 以图像形式显示

2.5 文件版本回退

# 这个命令会将仓库中的文件切换到指定的版本时候的样子
# CommitId可以使用log查看
git reset --hard <CommitId>

三、Git分支

分支可以有效的把当前模块的开发分离出来进行重大的BUG修改，或开发新的功能，以不影响开发的主线

1. 查看本地分支

# 查看当前本地仓库中的分支，每个仓库中的分支是独立的，互不影响
git branch

2. 创建本地分支

# 在当前本地仓库创建一个分支
git branch <分支的名称>

3. 切换分支

这个命令可以切换到指定的分子下，切换之后本地仓库文件会显示为当前分支的文件状态

git checkout <分支名称>

切换分支高级版：分支不存在创建 + 切换

git checkout -b <分支名称>

4. 合并分支

将指定分支的文件内容合并到当前分支

git merge <分支名称>

5. 删除分支

删除分支的时候不可以删除当前所在的分支，只可以删除别的分支

如：当前所在分支master，有另外分支dev1 那么我们可以在master分支删除dev1分支，若在dev1分支中是不可以删除dev1分支的

git branch -d <分支名称> # 删除分支时做检查

删除分支不做检查，直接删除

git branch -D <分支名称>

四、冲突解决

1. 冲突的发生

当两个分支上对同一个文件，的同一行进行修改，这时候就需要手动去解决冲突

2. 如何解决冲突

1. 处理文件中冲突的地方

   1. 选择要保留的内容，或要删除的内容
2. 将解决完冲突的文件加入到暂存区
3. 提交到仓库

3. 开发中分支使用原则与流程

几乎所有的版本控制系统都以某种形式支持分支。

使用分支意味着你可以把你的工作从开发主线上分离开来进行重大的Bug修改、开发新的功能，以免影响开发主线。

在开发中，一般有如下分支使用原则与流程：

• master （生产） 分支：线上分支，主分支，中小规模项目作为线上运行的应用对应的分支；
• develop（开发）分支：是从master创建的分支，一般作为开发部门的主要开发分支，如果没有其 他并行开发不同期上线要求，都可以在此版本进行开发，阶段开发完成后，需要是合并到master 分支，准备上线。
• feature/xxxx分支：从develop创建的分支，一般是同期并行开发，但不同期上线时创建的分支， 分支上的研发任务完成后合并到develop分支，之后该分支可以删除。
• hotfix/xxxx分支：从master派生的分支，一般作为线上bug修复使用，修复完成后需要合并到 master、test、develop分支。 还有一些其他分支，在此不再详述，例如test分支（用于代码测试）、pre分支（预上线分支）等。

五、Git远程仓库

1. GitHub（ 地址：https://github.com/ ）是一个面向开源及私有软件项目的托管平台，因为只支持 Git 作为唯一的版本库格式进行托管，故名GitHub
2. 码云（地址： https://gitee.com/ ）是国内的一个代码托管平台，由于服务器在国内，所以相比于 GitHub，码云速度会更快
3. GitLab （地址： https://about.gitlab.com/ ）是一个用于仓库管理系统的开源项目，使用Git作为 代码管理工具，并在此基础上搭建起来的web服务，一般用于在企业、学校等内部网络搭建git私 服。

以码云为例子

码云（地址： https://gitee.com/ ）

1. 创建远程仓库

2. 远程仓库地址

3. 配置 / 生成本地公钥

在Git命令窗口中执行下面代码

ssh-keygen -t ed25519 -C "xxxxx@xxxxx.com" 

其中xxxxx@xxxxx.com只是生成的 sshkey 的名称，并不约束或要求具体命名为某个邮箱。

现网的大部分教程均讲解的使用邮箱生成，其一开始的初衷仅仅是为了便于辨识所以使用了邮箱

按照提示完成三次回车，即可生成 ssh key。通过查看 ~/.ssh/id_ed25519.pub 文件内容，获取到你的 public key

cat ~/.ssh/id_ed25519.pub

4. 验证配置的公钥是否成功

ssh -T git@gitee.com

会提示输入Yes，直接输入yes,输出显示Git中配置的用户名即可算配置成功

六、远程仓库命令

0. 初始化远程仓库

要想连接到远程仓库，在远程仓库之前需要执行以下

• git init 将当前文件夹变为一个git仓库

git remote add <远程仓库名称一般是origin> <仓库地址SSH地址>

1. 查看远程仓库

# 查看当前远程仓库，如果返回一个 origin 那么绑定成功
git remote

2. 从远程仓库克隆项目

将远程仓库的项目克隆到本地，若不指定本地目录那么将会生成一个远程仓库一样的文件夹

git clone <仓库地址> [本地目录]

3. 拉取远程仓库

git fetch [远程仓库名称一般为origin] [分支名称不指定为所有分支]

上面这个命令可以简化为下面的一个命令

这个命令可以本地自动拉取和更新

git pull [远程仓库名称一般为origin] [分支名称不指定为所有分支]

4. 推送到远程仓库

将本地仓库的文件推送到远程仓库 master分支下

git push [origin] [master]

七、IDEA中使用Git

1. 配置Git

在IDEA中的设置，搜索Git，找到本机电脑上所装的Git.exe文件，即设置成功

出现对应的版本号就是配置成功了

2. 配置远程仓库

3. 配置本地仓库配置

有两个地方可以commit到本地仓库

在上面Git选择中commit或者点击这个 对号