基础

Spring是什么

Spring 是一个开源的框架，旨在解决企业应用开发的复杂性。它是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。Spring 的理念是使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架。

Spring有什么特性

Spring 拥有许多特性，使其成为一个非常受欢迎的框架。其中一些主要特性包括：

• 控制反转（IoC）：Spring 提供了一个 IoC 容器，将对象间的依赖关系交由 Spring 进行控制，从而实现了解耦。
• 面向切面编程（AOP）：Spring 提供了 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付。
• 声明式事务管理：Spring 支持声明式事务管理，可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务管理，提高开发效率和质量。
• 与其他框架的集成：Spring 可以与其他优秀的框架（如 Spring MVC、MyBatis、Struts2、Hibernate 等）集成，提供更多功能。

事务的两种实现方式

事务的两种方式一般指的是编程式事务和声明式事务。

• 编程式事务：指的是在代码中显式地控制事务的开始、提交、回滚等操作。这种方式可以给予开发者更大的灵活性，但也增加了编码的复杂度和维护成本。一般来说，编程式事务有两种方法可以实现：模板事务的方式（TransactionTemplate）和平台事务管理器方式（PlatformTransactionManager）。
• 声明式事务：指的是通过配置或注解来声明某个方法或类需要进行事务管理，而不需要在代码中进行事务操作。这种方式可以简化开发过程，让开发者只关注业务逻辑，而不用担心事务的细节。一般来说，声明式事务有两种方式可以实现：通过XML配置或通过注解。

下面是一个使用注解实现声明式事务的例子：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Transactional // 声明该方法需要进行事务管理
    public void transfer(String from, String to, int money) {
        userDao.reduceMoney(from, money); // 扣钱
        int i = 1 / 0; // 模拟异常
        userDao.addMoney(to, money); // 加钱
    }
}

下面是一个使用 TransactionTemplate 实现编程式事务的例子：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Autowired
    private TransactionTemplate transactionTemplate;

    public void transfer(String from, String to, int money) {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                try {
                    userDao.reduceMoney(from, money); // 扣钱
                    int i = 1 / 0; // 模拟异常
                    userDao.addMoney(to, money); // 加钱
                } catch (Exception e) {
                    status.setRollbackOnly(); // 发生异常，回滚事务
                }
            }
        });
    }
}

在这个例子中，我们使用了 TransactionTemplate 来管理事务。当发生异常时，我们调用 status.setRollbackOnly() 方法来回滚事务。

模板方法作用

在 Spring 框架中，有很多以 Template 结尾的类，例如 JdbcTemplate、RestTemplate、RedisTemplate 等。这些类都是模板类，它们的目的是为了简化开发过程，让开发者能够更快速、更方便地完成特定的任务。

模板类通常都遵循模板方法模式，它们定义了一个算法的骨架，将一些步骤的实现延迟到子类中。这样，子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。

例如，在使用 JdbcTemplate 类进行数据库操作时，我们不需要关心如何获取连接、如何处理异常、如何释放资源等细节，只需要关注 SQL 语句和参数即可。JdbcTemplate 类已经为我们封装好了所有的细节操作，我们只需要调用相应的方法即可。

下面是一个使用 JdbcTemplate 类进行数据库查询的例子：

@Autowired
private JdbcTemplate jdbcTemplate;

public List<User> findAll() {
    String sql = "SELECT * FROM user";
    return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
}

在这个例子中，我们使用了 JdbcTemplate 类的 query 方法来执行查询操作。我们只需要提供 SQL 语句和结果集映射器即可，其他的细节操作都由 JdbcTemplate 类来完成。

总之，模板类是为了简化开发过程而设计的。它们封装了一些通用的操作逻辑，让开发者能够更快速、更方便地完成特定的任务。

Spring 常用注解

• web: 这些注解都是 Spring MVC 框架中用于处理 HTTP 请求的注解。下面是一个简单的示例，演示了这些注解的用法：

@Controller // 声明这是一个控制器类
@RequestMapping("/users") // 映射请求路径
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping // 处理 GET 请求
    @ResponseBody // 将返回值序列化为 JSON
    public List<User> findAll() {
        return userService.findAll();
    }

    @PostMapping // 处理 POST 请求
    @ResponseBody
    public User create(@RequestBody User user) { // 从请求体中获取数据
        return userService.create(user);
    }

    @PutMapping("/{id}") // 处理 PUT 请求，路径中包含变量
    @ResponseBody
    public User update(@PathVariable Long id, @RequestBody User user) { // 从路径中获取变量
        user.setId(id);
        return userService.update(user);
    }

    @DeleteMapping("/{id}") // 处理 DELETE 请求，路径中包含变量
    @ResponseBody
    public void delete(@PathVariable Long id) { // 从路径中获取变量
        userService.delete(id);
    }
}

在这个例子中，我们定义了一个 UserController 类，用来处理用户相关的 HTTP 请求。我们使用了 @Controller 注解来声明这是一个控制器类，使用 @RequestMapping 注解来映射请求路径。

在类中，我们定义了四个方法，分别用来处理查询、创建、更新和删除用户的请求。我们使用了 @GetMapping、@PostMapping、@PutMapping 和 @DeleteMapping 注解来映射不同类型的 HTTP 请求。

在方法的参数中，我们使用了 @RequestBody 注解来从请求体中获取数据，使用了 @PathVariable 注解来从路径中获取变量。

在方法的返回值上，我们使用了 @ResponseBody 注解来将返回值序列化为 JSON。

• 容器 这些注解都是 Spring 框架中用于依赖注入和配置的注解。下面是对这些注解的简单介绍：

• @Component：用于标记一个类为 Spring 组件，表示这个类的对象可以由 Spring 容器来管理。它是一个通用的注解，可以用于任何类型的组件。

• @Service：用于标记一个类为业务逻辑组件，它是 @Component 的一个特殊形式。

• @Repository：用于标记一个类为数据访问组件，它是 @Component 的一个特殊形式。

• @Autowired：用于自动装配依赖，可以用在字段、构造函数、方法等地方。它会根据类型自动查找容器中匹配的 bean 进行注入。

• @Qualifier：用于指定具体要注入的 bean 的名称，通常与 @Autowired 注解一起使用。

• @Configuration：用于标记一个类为配置类，表示这个类中包含了 bean 的定义信息。

• @Value：用于将外部配置文件中的值注入到 bean 的属性中。

• @Bean：用于在配置类中定义一个 bean，表示这个方法返回的对象将被注册到 Spring 容器中。

• @Scope：用于指定 bean 的作用域，例如单例、原型等。

下面是一个简单的示例，演示了这些注解的用法：

@Configuration // 声明这是一个配置类
public class AppConfig {

    @Value("${app.name}") // 从外部配置文件中获取值
    private String appName;

    @Bean // 定义一个 bean
    @Scope("prototype") // 指定 bean 的作用域为原型
    public UserService userService() {
        return new UserServiceImpl(appName);
    }
}

@Service // 声明这是一个业务逻辑组件
public class UserServiceImpl implements UserService {

    private String appName;

    public UserServiceImpl(String appName) {
        this.appName = appName;
    }

    @Autowired // 自动装配依赖
    private UserDao userDao;

    @Autowired
    public void setUserDao(@Qualifier("userDaoImpl") UserDao userDao) { // 指定要注入的 bean 的名称
        this.userDao = userDao;
    }

    // 省略其他代码
}

@Repository // 声明这是一个数据访问组件
public class UserDaoImpl implements UserDao {
    // 省略代码
}

在这个例子中，我们定义了一个配置类 AppConfig，使用了 @Configuration、@Value、@Bean 和 @Scope 注解。

我们还定义了两个组件类 UserServiceImpl 和 UserDaoImpl，分别使用了 @Service 和 @Repository 注解。

在 UserServiceImpl 类中，我们使用了 @Autowired 和 @Qualifier 注解来自动装配依赖。

• AOP: @Aspect、@PointCut、@After@Before@Around
• 事务： @Transactional

Spring中应用了哪些设计模式

IOC

什么是IOC，什么是DI

IOC，叫控制反转，是指把创建对象的控制权从耦合的程序代码中转移到了容器中，而是由容器来管理对象Bean的声明周期。 IOC最主要的实现方式是DI，通过依赖注入的方式，将对象注入到需要它们的对象中，降低代码耦合。

DI方式

在 Spring 框架中，依赖注入有三种方式：构造函数注入、setter 方法注入和字段注入。

• 构造函数注入：通过构造函数的参数来注入依赖。这种方式可以保证依赖对象在使用前已经被正确初始化。
• setter 方法注入：通过 setter 方法来注入依赖。这种方式可以让我们在运行时动态更改依赖对象。
• 字段注入：直接在字段上注入依赖。这种方式简单方便，但会破坏封装性。

下面是一个简单的示例，演示了这三种依赖注入方式的用法：

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    // 构造函数注入
    @Autowired
    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }

    // setter 方法注入
    @Autowired
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    // 字段注入
    @Autowired
    private UserDao userDao;

    // 省略其他代码
}

在这个例子中，我们分别使用了构造函数注入、setter 方法注入和字段注入三种方式来注入 UserDao 对象。我们使用了 @Autowired 注解来标记需要进行自动装配的地方。

当然，也可以使用 XML 配置来实现依赖注入。下面是一个简单的示例：

<bean id="userDao" class="com.example.UserDaoImpl" />

<bean id="userService" class="com.example.UserServiceImpl">
    <!-- 构造函数注入 -->
    <constructor-arg ref="userDao" />

    <!-- setter 方法注入 -->
    <property name="userDao" ref="userDao" />
</bean>

在这个配置文件中，我们使用了 <constructor-arg> 标签来实现构造函数注入，使用了 <property> 标签来实现 setter 方法注入。

总之，Spring 框架提供了多种依赖注入方式，可以根据实际情况选择合适的方式进行依赖注入。

BeanFactory

BeanFactory 是 Spring 框架中最基础的容器接口，它定义了 IOC 容器的基本功能和规范。BeanFactory 提供了一种高级的配置机制，能够管理任何类型的对象。

BeanFactory 提供了一些方法来获取 bean 对象，例如 getBean、containsBean、isSingleton 等。我们可以使用这些方法来从容器中获取 bean 对象，或者查询容器中是否包含某个 bean。

下面是一个简单的示例，演示了如何使用 BeanFactory 来获取 bean 对象：

public class Main {
    public static void main(String[] args) {
        // 创建一个 Spring 容器
        BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 从容器中获取 bean 对象
        UserService userService = factory.getBean(UserService.class);

        // 使用 bean 对象
        List<User> users = userService.findAll();
    }
}

在这个例子中，我们创建了一个 ClassPathXmlApplicationContext 类型的 Spring 容器。这个类是 BeanFactory 接口的一个实现类，它能够从类路径下的 XML 配置文件中读取 bean 的定义信息。

然后，我们使用 getBean 方法从容器中获取了一个 UserService 类型的 bean 对象。最后，我们调用了这个 bean 对象的 findAll 方法来查询所有用户。

总之，BeanFactory 是 Spring 框架中最基础的容器接口。它提供了一些基本的方法来管理和获取 bean 对象。

BeanFactory 与 FactoryBean

BeanFactory 和 FactoryBean 是两个不同的接口，它们在 Spring 框架中扮演着不同的角色。

BeanFactory 是 Spring 框架中最基础的容器接口，它负责管理和创建 bean 对象。当您在 Spring 应用程序中定义一个 bean 时，BeanFactory 会负责根据您的配置创建和初始化该 bean 对象，并将其注入到需要使用它的地方。

FactoryBean 是一个用于创建复杂对象的工厂 bean 接口。当您需要创建一个复杂的对象，而该对象的创建过程无法通过简单的配置来完成时，您可以使用 FactoryBean 来封装该对象的创建逻辑。FactoryBean 本身也是一个 bean，它需要实现 getObject() 方法来返回它创建的对象。

下面是一个简单的使用 FactoryBean 的示例：

import org.springframework.beans.factory.FactoryBean;

public class MyFactoryBean implements FactoryBean<MyObject> {
    @Override
    public MyObject getObject() throws Exception {
        // 在这里实现 MyObject 对象的创建逻辑
        MyObject myObject = new MyObject();
        // ...
        return myObject;
    }

    @Override
    public Class<?> getObjectType() {
        return MyObject.class;
    }
}

在上面的代码中，我们定义了一个名为 MyFactoryBean 的 FactoryBean，它负责创建 MyObject 对象。我们在 getObject() 方法中实现了 MyObject 对象的创建逻辑。

然后，我们可以在 Spring 配置文件中定义一个 MyFactoryBean 的 bean，例如：

<bean id="myObject" class="com.example.MyFactoryBean"/>

现在，当我们在应用程序中注入 myObject bean 时，Spring 容器会自动调用 MyFactoryBean.getObject() 方法来创建 MyObject 对象。

ApplicantContext

ApplicationContext 是 Spring 框架中的一个高级容器接口，它继承了 BeanFactory 接口，并提供了更多的功能和服务。ApplicationContext 是 Spring 框架的核心接口，它代表了 Spring 容器的上下文。

ApplicationContext 提供了一些额外的方法和特性，例如：

• 国际化支持，能够访问不同语言的消息资源
• 事件发布和监听，能够发布和监听不同类型的事件
• 资源访问，能够访问不同来源的资源文件
• 应用层面的服务，如 AOP、事务管理等

下面是一个简单的示例，演示了如何使用 ApplicationContext 来获取 bean 对象：

public class Main {
    public static void main(String[] args) {
        // 创建一个 Spring 容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 从容器中获取 bean 对象
        UserService userService = context.getBean(UserService.class);

        // 使用 bean 对象
        List<User> users = userService.findAll();
    }
}

在这个例子中，我们创建了一个 ClassPathXmlApplicationContext 类型的 Spring 容器。这个类是 ApplicationContext 接口的一个实现类，它能够从类路径下的 XML 配置文件中读取 bean 的定义信息。

然后，我们使用 getBean 方法从容器中获取了一个 UserService 类型的 bean 对象。最后，我们调用了这个 bean 对象的 findAll 方法来查询所有用户。

总之，ApplicationContext 是 Spring 框架中的一个高级容器接口。它提供了更多的功能和服务，是 Spring 容器的上下文。

Spring Bean 的生命周期

• 通过构造函数实例化Bean
• 实例化Bean之后进行一些初始化操作
• 最后执行销毁方法

Spring 为什么要自动装配啊

自动装配（autowiring）是 Spring 框架中用于简化依赖注入的一种方式。它能够根据类型或名称自动查找容器中匹配的 bean 进行注入，无需手动指定依赖关系。

自动装配能够帮助我们简化配置，减少编码工作量。它能够自动处理依赖关系，让我们只需要关注业务逻辑，而不用担心依赖的细节。

下面是一个简单的示例，演示了如何使用自动装配来注入依赖：

@Service
public class UserServiceImpl implements UserService {

    @Autowired // 自动装配依赖
    private UserDao userDao;

    // 省略其他代码
}

在这个例子中，我们使用了 @Autowired 注解来标记需要进行自动装配的字段。当应用程序启动时，Spring 容器会根据类型自动查找容器中匹配的 UserDao bean 进行注入。

总之，自动装配是 Spring 框架中用于简化依赖注入的一种方式。它能够帮助我们简化配置，减少编码工作量。

单例Bean是线程安全的嘛

在 Spring 框架中，默认情况下，bean 的作用域是单例（singleton）。这意味着 Spring 容器只会创建一个 bean 实例，并且这个实例会被所有对它的引用所共享。

如果一个单例 bean 是线程安全的，那么它在多线程环境下不会出现线程安全问题。但是，如果一个单例 bean 不是线程安全的，那么它在多线程环境下可能会出现线程安全问题。

例如，如果一个单例 bean 中包含了可变的状态（例如非 final 的字段），并且这些状态没有被正确地同步，那么这个 bean 在多线程环境下可能会出现线程安全问题。

为了避免这种情况，我们应该尽量避免在单例 bean 中包含可变的状态。如果必须包含可变的状态，那么应该使用同步机制来保证线程安全。

总之，单例 bean 本身不会导致线程安全问题。但是，如果一个单例 bean 不是线程安全的，那么它在多线程环境下可能会出现线程安全问题。因此，我们应该注意保证单例 bean 的线程安全性。

解决线程安全问题

如果一个单例 bean 不是线程安全的，那么可以采取以下几种方式来解决线程安全问题：

1. 避免使用可变状态：尽量避免在单例 bean 中包含可变的状态。如果可以，尽量使用不可变对象来代替可变对象。

2. 使用同步机制：如果必须包含可变的状态，那么应该使用同步机制来保证线程安全。例如，可以使用 synchronized 关键字或 Lock 接口来实现同步。

3. 使用 ThreadLocal：如果每个线程都需要一个独立的状态，那么可以使用 ThreadLocal 来为每个线程提供一个独立的副本。

4. 更改 bean 的作用域：如果单例作用域不适用于当前的情况，那么可以考虑更改 bean 的作用域。例如，可以将 bean 的作用域更改为原型（prototype），这样每次获取 bean 时都会创建一个新的实例。

为什么会出现循环依赖问题

循环依赖（circular dependency）是指两个或多个 bean 之间相互依赖，形成了一个循环。例如，如果 bean A 依赖于 bean B，而 bean B 又依赖于 bean A，那么就形成了一个循环依赖。

循环依赖会导致 Spring 容器无法正确初始化这些 bean。当 Spring 容器尝试创建这些 bean 时，会发现它们之间存在循环依赖，无法确定它们的创建顺序。因此，Spring 容器会抛出一个 BeanCurrentlyInCreationException 异常，表示无法创建这些 bean。

下面是一个简单的示例，演示了如何产生循环依赖：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private OrderService orderService;

    // 省略其他代码
}

@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private UserService userService;

    // 省略其他代码
}

在这个例子中，UserServiceImpl 类依赖于 OrderService 类，而 OrderServiceImpl 类又依赖于 UserService 类。这就形成了一个循环依赖。

当 Spring 容器尝试创建这两个 bean 时，会发现它们之间存在循环依赖，无法确定它们的创建顺序。因此，Spring 容器会抛出一个 BeanCurrentlyInCreationException 异常。

总之，循环依赖是指两个或多个 bean 之间相互依赖，形成了一个循环。循环依赖会导致 Spring 容器无法正确初始化这些 bean。因此，我们应该避免在代码中产生循环依赖。

怎么解决循环依赖问题

Spring 框架能够解决部分循环依赖的问题。具体来说，Spring 容器能够解决单例 bean 之间的循环依赖，但是无法解决原型 bean 之间的循环依赖。

当 Spring 容器检测到单例 bean 之间存在循环依赖时，它会使用以下算法来解决这个问题：

1. 当 Spring 容器创建一个单例 bean 时，它会首先将这个 bean 标记为“当前正在创建”。
2. 然后，Spring 容器会尝试解析这个 bean 的依赖关系。如果发现这个 bean 依赖于另一个“当前正在创建”的 bean，那么就说明存在循环依赖。
3. 此时，Spring 容器会尝试使用已经创建好的部分实例来解决循环依赖。具体来说，它会将已经创建好的部分实例注入到其他 bean 中，从而打破循环依赖。

下面是一个简单的示例，演示了 Spring 容器是如何解决循环依赖的：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private OrderService orderService;

    public UserServiceImpl() {
        System.out.println("Creating UserServiceImpl");
    }

    // 省略其他代码
}

@Service
public class OrderServiceImpl implements OrderService {

    @Autowired
    private UserService userService;

    public OrderServiceImpl() {
        System.out.println("Creating OrderServiceImpl");
    }

    // 省略其他代码
}

在这个例子中，UserServiceImpl 类依赖于 OrderService 类，而 OrderServiceImpl 类又依赖于 UserService 类。这就形成了一个循环依赖。

当 Spring 容器尝试创建这两个 bean 时，它会按照以下步骤进行：

1. Spring 容器开始创建 UserServiceImpl 类的实例。此时，它会将这个实例标记为“当前正在创建”，并输出“Creating UserServiceImpl”。
2. 然后，Spring 容器尝试解析 UserServiceImpl 类的依赖关系。它发现这个类依赖于 OrderService 类，于是开始创建 OrderServiceImpl 类的实例。
3. 当 Spring 容器开始创建 OrderServiceImpl 类的实例时，它会将这个实例标记为“当前正在创建”，并输出“Creating OrderServiceImpl”。
4. 然后，Spring 容器尝试解析 OrderServiceImpl 类的依赖关系。它发现这个类依赖于 UserService 类，但是 UserService 类的实例已经标记为“当前正在创建”，说明存在循环依赖。
5. 此时，Spring 容器会使用已经创建好的 UserServiceImpl 类的部分实例来注入到 OrderServiceImpl 类中，从而打破循环依赖。

总之，Spring 框架能够解决部分循环依赖的问题。具体来说，Spring 容器能够解决单例 bean 之间的循环依赖，但是无法解决原型 bean 之间的循环依赖。

AOP

什么是AOP，应用场景

AOP（面向切面编程）是一种编程范式，它旨在将横切关注点（cross-cutting concerns）与业务逻辑分离，以提高代码的模块化和可维护性。

横切关注点是指那些与业务逻辑无关，但在多个模块或功能中都需要使用的功能，如日志记录、事务管理、安全检查等。在传统的编程范式中，这些功能通常会直接嵌入到业务逻辑中，导致代码重复和耦合度高，难以维护和扩展。

AOP通过引入切面（Aspect）的概念，将横切关注点与业务逻辑分离。切面是一种特殊的模块，它定义了横切关注点的实现，并通过切入点（Pointcut）和通知（Advice）来指定横切关注点应该在何时何地被织入（weave）到业务逻辑中。这样可以将横切关注点的实现与业务逻辑分离，提高代码的模块化和可维护性。

例如，在一个Web应用程序中，我们可能需要在每个控制器方法执行之前和之后记录日志。使用AOP，我们可以定义一个日志切面，指定切入点为所有控制器方法，通知为在方法执行之前和之后记录日志。这样就可以将日志记录的实现与控制器方法的业务逻辑分离，避免在每个控制器方法中都添加重复的日志记录代码。 已发送电子邮件. AOP的应用场景 AOP（面向切面编程）可以应用于许多场景，主要用于解决横切关注点（cross-cutting concerns）问题。下面是一些常见的AOP应用场景：

日志记录：可以使用AOP来记录应用程序的运行日志，如方法调用日志、异常日志等。这样可以将日志记录的实现与业务逻辑分离，避免在每个方法中都添加重复的日志记录代码。

性能监控：可以使用AOP来监控应用程序的性能，如方法执行时间、内存占用等。这样可以将性能监控的实现与业务逻辑分离，避免在每个方法中都添加重复的性能监控代码。

事务管理：可以使用AOP来管理数据库事务，如开启事务、提交事务、回滚事务等。这样可以将事务管理的实现与业务逻辑分离，避免在每个方法中都添加重复的事务管理代码。

安全检查：可以使用AOP来检查用户的权限和身份，如登录检查、权限检查等。这样可以将安全检查的实现与业务逻辑分离，避免在每个方法中都添加重复的安全检查代码。

异常处理：可以使用AOP来统一处理应用程序中的异常，如记录异常日志、发送异常通知等。这样可以将异常处理的实现与业务逻辑分离，避免在每个方法中都添加重复的异常处理代码。

JDK动态代理 和 CGlib动态代理

JDK动态代理是Java提供的一种代理实现方式，它允许开发人员在运行时动态地创建代理对象。下面是一个简单的例子，它演示了如何使用JDK动态代理来创建一个代理对象：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface MyInterface {
    void doSomething();
}

class MyClass implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("MyClass doing something");
    }
}

class MyInvocationHandler implements InvocationHandler {
    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method call");
        Object result = method.invoke(target, args);
        System.out.println("After method call");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        MyInvocationHandler handler = new MyInvocationHandler(myClass);
        MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
                Main.class.getClassLoader(),
                new Class[]{MyInterface.class},
                handler);
        proxy.doSomething();
    }
}

在上面的例子中，我们定义了一个接口MyInterface和一个实现类MyClass。我们还定义了一个调用处理器类MyInvocationHandler，它实现了InvocationHandler接口。在调用处理器的invoke方法中，我们在调用目标方法之前和之后分别打印了一条信息。

在主方法中，我们首先创建了一个MyClass实例和一个MyInvocationHandler实例。然后，我们使用Proxy.newProxyInstance方法创建了一个代理对象。这个方法接收三个参数：类加载器、接口数组和调用处理器。最后，我们调用了代理对象的doSomething方法。

当我们运行上面的代码时，会看到如下输出：

Before method call
MyClass doing something
After method call

从输出中可以看出，在调用目标方法之前和之后，调用处理器的invoke方法都被执行了。这就是JDK动态代理的基本用法。

CGLib动态代理是一种代理实现方式，它允许开发人员在运行时动态地创建代理对象。与JDK动态代理不同，CGLib动态代理不要求目标对象实现接口。下面是一个简单的例子，它演示了如何使用CGLib动态代理来创建一个代理对象：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

class MyClass {
    public void doSomething() {
        System.out.println("MyClass doing something");
    }
}

class MyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before method call");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("After method call");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(MyClass.class);
        enhancer.setCallback(new MyMethodInterceptor());
        MyClass myClass = (MyClass) enhancer.create();
        myClass.doSomething();
    }
}

在上面的例子中，我们定义了一个类MyClass，它包含一个方法doSomething。我们还定义了一个方法拦截器类MyMethodInterceptor，它实现了MethodInterceptor接口。在方法拦截器的intercept方法中，我们在调用目标方法之前和之后分别打印了一条信息。

在主方法中，我们首先创建了一个Enhancer实例。然后，我们使用setSuperclass方法设置了目标类，并使用setCallback方法设置了方法拦截器。最后，我们使用create方法创建了一个代理对象，并调用了它的doSomething方法。

当我们运行上面的代码时，会看到如下输出：

Before method call
MyClass doing something
After method call

从输出中可以看出，在调用目标方法之前和之后，方法拦截器的intercept方法都被执行了。这就是CGLib动态代理的基本用法。

Spring AOP 和 AspectJ AOP之间的区别

Spring AOP和AspectJ AOP都是实现AOP（面向切面编程）的框架，它们都提供了丰富的注解和API来定义切面（Aspect）、切入点（Pointcut）和通知（Advice）。但它们之间也有一些区别，主要体现在以下几个方面：

• 实现方式：Spring AOP是基于代理（Proxy）实现的，它在运行时动态生成目标对象的代理对象，然后在代理对象中织入切面逻辑。而AspectJ AOP是基于字节码操作（Bytecode Manipulation）实现的，它在编译时或加载时对目标类的字节码进行修改，直接在目标类中织入切面逻辑。

• 功能范围：由于Spring AOP是基于代理实现的，所以它只能对Spring容器管理的Bean进行增强，无法对非Spring容器管理的对象进行增强。而AspectJ AOP由于是基于字节码操作实现的，所以它可以对任何对象进行增强，不受Spring容器的限制。

• 性能开销：Spring AOP由于是在运行时动态生成代理对象，所以它会带来一定的性能开销。而AspectJ AOP由于是在编译时或加载时对字节码进行修改，所以它对运行时性能的影响较小。

下面是一个简单的例子，演示如何使用Spring AOP和AspectJ AOP来定义一个日志切面：

使用Spring AOP：

@Aspect
@Component
public class LogAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void before(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Before method: " + methodName);
    }
}

使用AspectJ AOP：

@Aspect
public class LogAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void before(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Before method: " + methodName);
    }
}

从上面的例子可以看出，使用Spring AOP和AspectJ AOP定义切面的语法基本相同，都是通过@Aspect注解来定义切面类，然后使用@Before、@After、@Around等注解来定义通知方法。不同之处在于，使用Spring AOP时需要将切面类声明为Spring容器管理的Bean（如使用@Component注解），而使用AspectJ AOP时则不需要。

什么是编译时、加载时、运行时

编译时、加载时和运行时是指Java程序从源代码到运行的三个阶段：

• 编译时：编译时是指将Java源代码编译成字节码的过程。在这个阶段，Java编译器（javac）会对源代码进行语法检查、类型检查等，然后将源代码翻译成字节码文件（.class文件）。

• 加载时：加载时是指将字节码文件加载到JVM中的过程。在这个阶段，JVM会通过类加载器（ClassLoader）来加载字节码文件，然后对字节码进行验证、准备和解析等操作。

• 运行时：运行时是指JVM执行字节码的过程。在这个阶段，JVM会通过解释器（Interpreter）或即时编译器（JIT Compiler）来执行字节码，完成程序的运行。

下面是一个简单的例子，演示Java程序从源代码到运行的过程：

假设有一个名为HelloWorld.java的Java源文件，内容如下：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

首先，在编译时阶段，我们可以使用javac命令来编译这个源文件：

javac HelloWorld.java

经过编译后，会生成一个名为HelloWorld.class的字节码文件。

然后，在加载时阶段，当我们使用java命令来运行这个程序时，JVM会通过类加载器来加载HelloWorld.class文件，并对其进行验证、准备和解析等操作。

最后，在运行时阶段，JVM会通过解释器或即时编译器来执行HelloWorld.class文件中的字节码，完成程序的运行。最终在控制台输出Hello, World!。

事务

Spring事务种类

Spring事务的隔离级别

Spring事务传播机制是干嘛的

在Spring中，事务的传播机制（Transaction Propagation）是指在多个事务方法嵌套调用时，如何管理事务的行为。Spring提供了7种事务传播行为，可以通过在@Transactional注解中指定propagation属性来设置。

下面是7种事务传播行为的说明：

• PROPAGATION_REQUIRED：如果当前没有事务，就新建一个事务；如果当前存在事务，就加入到当前事务中。这是默认的传播行为。

• PROPAGATION_SUPPORTS：如果当前存在事务，就加入到当前事务中；如果当前没有事务，就以非事务方式执行。

• PROPAGATION_MANDATORY：如果当前存在事务，就加入到当前事务中；如果当前没有事务，就抛出异常。

• PROPAGATION_REQUIRES_NEW：新建一个事务，并暂停当前的事务（如果存在）。

• PROPAGATION_NOT_SUPPORTED：以非事务方式执行，并暂停当前的事务（如果存在）。

• PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，就抛出异常。

• PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行；如果当前没有事务，则新建一个事务。嵌套事务是指在一个大的外围事务中，可以有多个小的嵌套事务。外围事务提交时，所有嵌套事务也会提交；外围事务回滚时，所有嵌套事务也会回滚。但嵌套事务回滚时，不会影响外围事务。

下面是一个简单的例子，演示如何使用不同的传播行为：

@Service
public class MyService {
    @Transactional(propagation = Propagation.REQUIRED)
    public void methodA() {
        // do something
        methodB();
        // do something
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void methodB() {
        // do something
    }
}

在上面的例子中，methodA和methodB都被声明为@Transactional方法。当调用methodA时，会新建一个事务；当调用methodB时，由于它的传播行为被设置为Propagation.REQUIRES_NEW，所以会新建一个新的事务，并暂停methodA中的事务。当methodB执行完毕后，会提交新建的事务，并恢复methodA中的事务。

MVC

Spring MVC的核心组件以及工作流程

对Spring MVC的理解： 一个客户端请求来了之后的调用逻辑，是调用Controller层对应的方法，然后Controller层调用Service，Service调用DAO层，最后将处理完成的数据封装在Model中，把model数据给视图层渲染处理，将最终结果返回给浏览器，进行解析展示。

1. 浏览器发送请求到DispacherServlet(前端控制器)
2. 前端控制器将请求发给HandlerMapping(处理器映射器)查找Handler
3. 处理器映射器返回一个执行链
4. DS请求处理器适配器执行Handler
5. 处理器适配器找到对应Handler执行器，将执行后的结果ModelAndView返回给DS
6. DS通过视图解析器进行 进行视图解析
7. 然后将视图进行渲染
8. 将渲染后的结果返回给浏览器进行解析展示

MyBatis

核心组件：

• SqlSessionFactory:用于创建SqlSession的工厂类
• SqlSession用于向数据库执行SQL
• Mapper接口：就是DAO接口，在Mabatis中习惯称之为Mapper
• Mapper映射器：通过用于编写SQL，采用XML、注解方式实现

#{} 与 ${}之间的区别

#{} 与 ${}都是取变量值的

• #{}取出来的变量的value值会加上"",${}取出来的value值不会加""
• #{}可以防止SQL注入，${}不可以防止SQL注入

日志级别

OFF: 关闭所有日志记录 FATAL：打印非常严重的可能导致应用终止的错误事件 ERROR：打印错误事件 WARN：可能的潜在危险事件 INFO：粗粒度描述应用运行过程 DEBUG：细粒度描述应用运行过程 Trace：更加细粒度描述应用运行过程 ALL：打印全部日志

SpringBoot

为什么还会出现Spring Boot

Spring Boot是基于Spring框架开发的一种新技术，它旨在简化Spring应用程序的创建和开发过程。虽然Spring框架功能强大，但它的配置和使用也相对复杂，需要开发人员具备较高的技能水平。Spring Boot通过提供一系列的自动配置、启动器和命令行工具，来简化Spring应用程序的创建和开发过程。

下面是Spring Boot相对于Spring框架的一些优点：

• 简化配置：Spring Boot提供了大量的自动配置，可以根据项目的依赖关系自动配置常用的组件，如数据源、JPA、Web MVC等。这样可以减少开发人员需要编写的配置代码，简化开发过程。

• 快速开发：Spring Boot提供了大量的启动器（Starter），可以快速集成常用的组件和框架，如JDBC、MongoDB、Redis等。这样可以减少开发人员需要编写的集成代码，提高开发效率。

• 灵活部署：Spring Boot支持多种部署方式，可以将应用程序打包成可执行的JAR或WAR文件，也可以直接在命令行中运行。这样可以灵活地部署应用程序，满足不同的部署需求。

• 监控运维：Spring Boot提供了丰富的监控和运维功能，可以方便地监控应用程序的运行状态、性能指标和日志信息。这样可以帮助运维人员快速定位问题，提高运维效率。

总之，Spring Boot是基于Spring框架开发的一种新技术，它通过提供一系列简化配置和快速开发的功能，来简化Spring应用程序的创建和开发过程。

Spring Boot自动装配原理

在Spring Boot中，自动配置（Auto-configuration）是指根据项目的依赖关系和配置信息，自动配置常用的组件和框架。自动配置是通过@EnableAutoConfiguration注解来启用的，它会扫描项目的类路径，查找所有可用的自动配置类，并根据条件进行匹配和配置。

自动配置类通常以AutoConfiguration结尾，如DataSourceAutoConfiguration、JpaAutoConfiguration等。它们都位于org.springframework.boot.autoconfigure包下，可以通过查看源代码来了解它们的实现细节。

自动配置类通常使用@ConditionalOnXXX注解来定义条件，如@ConditionalOnClass、@ConditionalOnBean、@ConditionalOnProperty等。只有当条件满足时，才会执行自动配置。

下面是一个简单的例子，演示如何使用自动配置来配置数据源：

假设我们在项目中添加了spring-boot-starter-jdbc依赖，那么Spring Boot会自动检测到这个依赖，并尝试进行数据源的自动配置。

首先，Spring Boot会查找所有可用的自动配置类，并找到DataSourceAutoConfiguration类。然后，它会检查这个类上的条件是否满足。由于我们添加了JDBC依赖，所以条件满足。

接下来，Spring Boot会执行这个类中定义的自动配置逻辑。它会根据我们在配置文件中指定的数据源类型、驱动程序、URL、用户名和密码等信息，来创建一个数据源对象，并将其注册到Spring容器中。

最后，我们就可以在应用程序中直接使用这个数据源对象了，无需手动进行配置。

Spring Boot 启动原理

Spring Boot应用程序的启动过程包括以下几个步骤：

1. 创建一个SpringApplication对象实例，该对象负责管理应用程序的启动过程。

SpringApplication app = new SpringApplication(MyApplication.class);

2. 调用SpringApplication对象的run方法来启动应用程序。该方法会执行以下操作：

• 加载应用程序上下文（Application Context）。
• 注册命令行属性（Command Line Properties）。
• 加载外部配置文件（External Configuration）。
• 加载应用程序参数（Application Arguments）。
• 初始化日志系统（Logging System）。
• 初始化应用程序事件监听器（Application Event Listeners）。
• 准备环境（Environment）。
• 打印Banner信息（Banner）。
• 创建并刷新应用程序上下文（Application Context）。

app.run(args);

3. 应用程序上下文创建完成后，Spring Boot会自动执行以下操作：

• 执行所有CommandLineRunner和ApplicationRunner接口的实现类。
• 发布ApplicationReadyEvent事件。

下面是一个简单的例子，演示如何启动一个Spring Boot应用程序：

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

在上面的例子中，我们使用了@SpringBootApplication注解来标记这是一个Spring Boot应用程序。然后在main方法中，调用了SpringApplication.run方法来启动应用程序。

SpringCloud

为什么会出现Spring Cloud呢

随着互联网技术的快速发展，越来越多的企业开始采用微服务架构来构建大型分布式系统。微服务架构通过将系统拆分为多个独立的服务，实现了系统的高内聚、低耦合和可扩展性。但同时，微服务架构也带来了一些新的挑战，如服务治理、配置管理、服务发现等。

Spring Cloud应运而生，它是一套基于Spring Boot开发的微服务架构解决方案。它提供了一系列工具和组件，可以帮助开发人员快速构建分布式系统，并解决微服务架构中的一些常见问题。

Spring Cloud提供了以下功能：

• 服务发现：Spring Cloud提供了多种服务发现组件，如Eureka、Consul、Zookeeper等。这些组件可以帮助服务之间相互发现和调用。

• 配置管理：Spring Cloud提供了配置中心组件，如Spring Cloud Config。它可以帮助开发人员统一管理分布式系统中的配置信息。

• 负载均衡：Spring Cloud提供了客户端负载均衡组件，如Ribbon。它可以帮助开发人员实现客户端负载均衡，提高系统的可用性。

• 断路器：Spring Cloud提供了断路器组件，如Hystrix。它可以帮助开发人员实现服务降级和熔断，提高系统的容错能力。

• API网关：Spring Cloud提供了API网关组件，如Zuul。它可以帮助开发人员实现API路由、过滤和安全校验等功能。

总之，Spring Cloud是一套基于Spring Boot开发的微服务架构解决方案。它通过提供一系列工具和组件，来帮助开发人员快速构建分布式系统，并解决微服务架构中的一些常见问题。

有哪些微服务的框架

您提到的三种微服务框架都是目前比较流行的解决方案，它们各有优势：

• Spring Cloud Netflix：Spring Cloud Netflix是Spring Cloud体系中基于Netflix开源组件实现的一套微服务框架。它提供了丰富的组件，如Eureka（服务发现）、Ribbon（客户端负载均衡）、Hystrix（断路器）、Zuul（API网关）等。这些组件都经过了Netflix公司大规模生产环境的验证，具有很高的可靠性和稳定性。

• Spring Cloud Alibaba：Spring Cloud Alibaba是阿里巴巴开源的一套微服务框架，它基于Spring Cloud体系，提供了丰富的组件，如Nacos（服务发现和配置管理）、Sentinel（流量控制和熔断）、RocketMQ（消息中间件）等。这些组件都经过了阿里巴巴大规模生产环境的验证，具有很高的可靠性和稳定性。

• Spring Boot + Dubbo + ZooKeeper：这种方案结合了Spring Boot、Dubbo和ZooKeeper三个优秀的开源项目。Spring Boot提供了快速开发和简化配置的能力；Dubbo提供了高性能的RPC通信和丰富的服务治理功能；ZooKeeper提供了分布式协调和配置管理能力。这种方案可以满足大多数微服务架构的需求，具有很高的灵活性和可扩展性。

Spring Cloud Netflix有哪些微服务组件

Spring Cloud Netflix是Spring Cloud体系中基于Netflix开源组件实现的一套微服务框架。它提供了丰富的组件，可以帮助开发人员快速构建分布式系统，并解决微服务架构中的一些常见问题。下面是Spring Cloud Netflix中常用的一些微服务组件：

• Eureka：Eureka是一个服务发现组件，它提供了服务注册和发现的功能。服务提供者可以将自己注册到Eureka服务器上，服务消费者可以从Eureka服务器上查询可用的服务列表。

• Ribbon：Ribbon是一个客户端负载均衡组件，它提供了多种负载均衡策略，可以帮助服务消费者在多个可用的服务提供者之间进行负载均衡。

• Hystrix：Hystrix是一个断路器组件，它提供了服务降级和熔断的功能。当某个服务出现故障时，Hystrix可以自动进行服务降级或熔断，避免故障扩散。

• Zuul：Zuul是一个API网关组件，它提供了API路由、过滤和安全校验等功能。Zuul可以作为系统的统一入口，对外提供API服务。

• Feign：Feign是一个声明式的HTTP客户端，它提供了一种简单的方式来调用远程HTTP接口。Feign支持多种注解风格，如JAX-RS、Spring MVC等。

以上是Spring Cloud Netflix中常用的一些微服务组件，它们都经过了Netflix公司大规模生产环境的验证，具有很高的可靠性和稳定性。希望这些信息能够帮助您了解Spring Cloud Netflix中常用的微服务组件。

Spring Cloud Alibaba中有哪些微服务的组件

Spring Cloud Alibaba是阿里巴巴开源的一套微服务框架，它基于Spring Cloud体系，提供了丰富的组件，可以帮助开发人员快速构建分布式系统，并解决微服务架构中的一些常见问题。下面是Spring Cloud Alibaba中常用的一些微服务组件：

• Nacos：Nacos是一个服务发现和配置管理组件，它提供了服务注册、发现和配置管理的功能。服务提供者可以将自己注册到Nacos服务器上，服务消费者可以从Nacos服务器上查询可用的服务列表。此外，Nacos还提供了配置管理功能，可以帮助开发人员统一管理分布式系统中的配置信息。

• Sentinel：Sentinel是一个流量控制和熔断组件，它提供了流量控制、熔断降级和系统自适应保护等功能。Sentinel可以帮助开发人员实现对微服务架构中的流量进行控制和保护。

• RocketMQ：RocketMQ是一个消息中间件，它提供了高性能、高可靠性和高可扩展性的消息传递能力。RocketMQ支持多种消息模型，如发布/订阅、点对点等。

• Dubbo：Dubbo是阿里巴巴开源的一款高性能的Java RPC框架。它提供了丰富的服务治理功能，如服务发现、负载均衡、容错等。Dubbo支持多种协议和注册中心，可以满足不同场景下的需求。

• Seata：Seata是一个分布式事务解决方案，它提供了AT、TCC、SAGA和XA四种分布式事务模式。Seata可以帮助开发人员解决微服务架构中分布式事务的问题。

以上是Spring Cloud Alibaba中常用的一些微服务组件，它们都经过了阿里巴巴大规模生产环境的验证，具有很高的可靠性和稳定性。希望这些信息能够帮助您了解Spring Cloud Alibaba中常用的微服务组件。

微服务组件

Eureka的基本使用

首先，您需要在您的项目中添加 Eureka Server 的依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

然后，在您的应用程序主类上添加 @EnableEurekaServer 注解来启用 Eureka 服务端功能：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

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

接下来，您需要在您的配置文件中添加一些 Eureka Server 的配置，例如：

server:
  port: 8761

eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false

现在，您可以运行您的应用程序来启动 Eureka 服务端。

接下来，我们来看一个简单的 Eureka 客户端示例。

首先，您需要在您的项目中添加 Eureka Client 的依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

然后，在您的应用程序主类上添加 @EnableEurekaClient 注解来启用 Eureka 客户端功能：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

接下来，您需要在您的配置文件中添加一些 Eureka Client 的配置，例如：

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/

现在，您可以运行您的应用程序来启动 Eureka 客户端。它将自动向 Eureka 服务端注册，并从中获取服务列表。

Nacos的使用

首先，您需要在您的项目中添加 Nacos 客户端的依赖：

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

然后，在您的应用程序主类上添加 @EnableDiscoveryClient 注解来启用服务发现功能：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

接下来，您需要在您的配置文件中添加一些 Nacos 客户端的配置，例如：

spring:
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848

现在，您可以运行您的应用程序来启动 Nacos 客户端。它将自动向 Nacos 服务端注册，并从中获取服务列表。

Nacos 服务端的安装和运行与 Eureka 服务端有所不同。Nacos 服务端是一个独立的应用程序，您需要从 Nacos 的官方网站下载并安装它。

首先，您需要从 Nacos 的 GitHub 发布页面下载最新版本的 Nacos 服务端。

然后，您需要解压下载的文件，并进入解压后的目录。

接下来，您可以运行以下命令来启动 Nacos 服务端：

sh startup.sh -m standalone 复制 这将以单机模式启动 Nacos 服务端。在生产环境中，您可能需要使用集群模式来运行 Nacos 服务端以获得更好的可靠性和可扩展性。

现在，您可以访问 http://localhost:8848/nacos 来访问 Nacos 控制台。默认用户名和密码都是 nacos。

Ribbon的基本使用

Ribbon 是一个客户端负载均衡器，它可以与 Eureka 或其他服务发现组件一起使用，以在客户端实现负载均衡。

下面是一个简单的使用 Ribbon 的示例。

首先，您需要在您的项目中添加 Ribbon 的依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

然后，您需要创建一个 RestTemplate bean，并使用 @LoadBalanced 注解来启用负载均衡功能：

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

@Configuration
public class RibbonConfiguration {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

现在，您可以在您的应用程序中使用 RestTemplate 来发起 HTTP 请求。Ribbon 将自动为您选择一个可用的服务实例，并将请求路由到该实例。

例如，假设您有一个名为 my-service 的服务，您可以使用以下代码来调用该服务的 /hello 接口：

@Autowired
private RestTemplate restTemplate;

public String hello() {
    return restTemplate.getForObject("http://my-service/hello", String.class);
}

Hytrix的使用

Hystrix 是一个断路器组件，它可以帮助您的应用程序在依赖的服务出现故障时保持可用。

下面是一个简单的使用 Hystrix 的示例。

首先，您需要在您的项目中添加 Hystrix 的依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

然后，在您的应用程序主类上添加 @EnableCircuitBreaker 注解来启用断路器功能：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;

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

接下来，您可以在您的应用程序中使用 @HystrixCommand 注解来为您的方法添加断路器功能。例如，假设您有一个方法用于调用远程服务，您可以使用以下代码来为该方法添加断路器功能：

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class MyService {
    private final RestTemplate restTemplate;

    public MyService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @HystrixCommand(fallbackMethod = "fallback")
    public String hello() {
        return restTemplate.getForObject("http://my-service/hello", String.class);
    }

    public String fallback() {
        return "fallback";
    }
}

在上面的代码中，我们使用 @HystrixCommand 注解来为 hello 方法添加断路器功能。当调用远程服务失败时，Hystrix 将自动调用 fallback 方法来返回一个备选结果。

Sentinel的基本使用

Sentinel 是一个流量控制和熔断降级组件，它可以帮助您的应用程序在面对流量高峰或依赖的服务出现故障时保持可用。

下面是一个简单的使用 Sentinel 的示例。

首先，您需要在您的项目中添加 Sentinel 的依赖：

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

然后，您需要在您的配置文件中添加一些 Sentinel 的配置，例如：

spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080

上面的配置指定了 Sentinel 控制台的地址。您需要运行一个 Sentinel 控制台来管理您的应用程序的流量控制规则。

接下来，您可以在您的应用程序中使用 @SentinelResource 注解来为您的方法添加流量控制功能。例如，假设您有一个方法用于处理用户请求，您可以使用以下代码来为该方法添加流量控制功能：

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import org.springframework.stereotype.Service;

@Service
public class MyService {
    @SentinelResource(value = "hello", fallback = "fallback")
    public String hello() {
        return "hello";
    }

    public String fallback() {
        return "fallback";
    }
}

在上面的代码中，我们使用 @SentinelResource 注解来为 hello 方法添加流量控制功能。当该方法的流量超过预设阈值时，Sentinel 将自动调用 fallback 方法来返回一个备选结果。

Feign的基本使用

Feign 是一个声明式的 REST 客户端，它可以帮助您简化远程服务调用的代码。

下面是一个简单的使用 Feign 的示例。

首先，您需要在您的项目中添加 Feign 的依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

然后，在您的应用程序主类上添加 @EnableFeignClients 注解来启用 Feign 客户端功能：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

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

接下来，您可以创建一个接口，并使用 @FeignClient 注解来定义一个 Feign 客户端。例如，假设您有一个名为 my-service 的服务，您可以使用以下代码来定义一个 Feign 客户端：

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

@FeignClient(name = "my-service")
public interface MyServiceClient {
    @GetMapping("/hello")
    String hello();
}

现在，您可以在您的应用程序中注入 MyServiceClient 接口，并使用它来调用远程服务。例如：

@Autowired
private MyServiceClient myServiceClient;

public String hello() {
    return myServiceClient.hello();
}

Dubbo的基本使用

Dubbo 是一个分布式服务框架，它可以帮助您实现服务之间的远程调用。

下面是一个简单的使用 Dubbo 的示例。

首先，您需要在您的项目中添加 Dubbo 的依赖：

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-dubbo</artifactId>
</dependency>

然后，您需要定义一个服务接口，并在服务提供方实现该接口。例如，假设您有一个名为 MyService 的服务接口，您可以使用以下代码来定义该接口：

public interface MyService {
    String hello(String name);
}

接下来，您需要在服务提供方实现该接口，并使用 @Service 注解来将其暴露为 Dubbo 服务：

import org.apache.dubbo.config.annotation.Service;

@Service
public class MyServiceImpl implements MyService {
    @Override
    public String hello(String name) {
        return "Hello, " + name;
    }
}

现在，您可以在服务消费方使用 @Reference 注解来引用该服务。例如：

import org.apache.dubbo.config.annotation.Reference;
import org.springframework.stereotype.Component;

@Component
public class MyConsumer {
    @Reference
    private MyService myService;

    public String hello(String name) {
        return myService.hello(name);
    }
}

zuul的基本使用

Zuul 是一个 API 网关组件，它可以帮助您管理和路由您的微服务架构中的请求。

下面是一个简单的使用 Zuul 的示例。

首先，您需要在您的项目中添加 Zuul 的依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>

然后，在您的应用程序主类上添加 @EnableZuulProxy 注解来启用 Zuul 网关功能：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

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

接下来，您需要在您的配置文件中添加一些 Zuul 的配置，例如：

zuul:
  routes:
    my-service:
      path: /my-service/**
      serviceId: my-service

上面的配置定义了一个路由规则，它将所有以 /my-service/ 开头的请求路由到名为 my-service 的服务。

现在，您可以运行您的应用程序来启动 Zuul 网关。当您向 Zuul 发送请求时，它将根据您定义的路由规则将请求路由到相应的服务。

gateway的基本使用

Spring Cloud Gateway 是一个 API 网关组件，它可以帮助您管理和路由您的微服务架构中的请求。

下面是一个简单的使用 Spring Cloud Gateway 的示例。

首先，您需要在您的项目中添加 Spring Cloud Gateway 的依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

然后，您需要在您的配置文件中添加一些 Spring Cloud Gateway 的配置，例如：

spring:
  cloud:
    gateway:
      routes:
        - id: my-service
          uri: lb://my-service
          predicates:
            - Path=/my-service/**

上面的配置定义了一个路由规则，它将所有以 /my-service/ 开头的请求路由到名为 my-service 的服务。

现在，您可以运行您的应用程序来启动 Spring Cloud Gateway。当您向 Spring Cloud Gateway 发送请求时，它将根据您定义的路由规则将请求路由到相应的服务。

sleuth、zipkin的基本使用

Sleuth 和 Zipkin 是两个用于分布式跟踪的组件，它们可以帮助您跟踪和调试您的微服务架构中的请求。

下面是一个简单的使用 Sleuth 和 Zipkin 的示例。

首先，您需要在您的项目中添加 Sleuth 和 Zipkin 的依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

然后，您需要在您的配置文件中添加一些 Sleuth 和 Zipkin 的配置，例如：

spring:
  zipkin:
    base-url: http://localhost:9411/
  sleuth:
    sampler:
      probability: 1.0

上面的配置指定了 Zipkin 服务端的地址，并将采样率设置为 100%。

现在，您可以运行您的应用程序来启动 Sleuth 和 Zipkin。当您的应用程序处理请求时，Sleuth 将自动为每个请求生成一个跟踪 ID，并将跟踪信息发送到 Zipkin 服务端。

您可以访问 Zipkin 控制台来查看您的应用程序的跟踪信息。

Kubenetes

Pod

apiVersion: v1 # 指定 Kubernetes API 的版本
kind: Pod # 指定资源类型为 Pod
metadata: # 资源元数据
  name: nginx # Pod 的名称
  namespace: dev # Pod 所属的命名空间
  labels: # Pod 的标签，用于标识和选择 Pod
    version: "3.0" # 自定义标签，表示版本号
    env: "test" # 自定义标签，表示环境类型
spec: # Pod 的规格描述
  containers: # Pod 中的容器列表
  - image: nginx:latest # 容器使用的镜像
    name: pod # 容器的名称
    ports: # 容器暴露的端口列表
    - name: nginx-port # 端口的名称
      containerPort: 80 # 容器内部的端口号
      protocol: TCP # 端口使用的协议

Pod 重启策略

• Always ：容器失效时，自动重启该容器，这也是默认值。
• OnFailure ： 容器终止运行且退出码不为0时重启
• Never ： 不论状态为何，都不重启该容器

Pod调度

• 自动调度：运行在哪个节点上完全由Scheduler经过一系列的算法计算得出
• 定向调度：NodeName、NodeSelector
• 亲和性调度：NodeAffinity、PodAffinity、PodAntiAffinity
• 污点（容忍）调度：Taints、Toleration

Pod控制器

• ReplicaSet：ReplicaSet的主要作用是保证一定数量的pod正常运行，它会持续监听这些Pod的运行状态，一旦Pod发生故障，就会重启或重建。
• Deployment：这种控制器并不直接管理pod，而是通过管理ReplicaSet来简介管理Pod，即：Deployment管理ReplicaSet，ReplicaSet管理Pod。所以Deployment比ReplicaSet功能更加强大。
• HPA：其实HPA与之前的Deployment一样，也属于一种Kubernetes资源对象，它通过追踪分析RC控制的所有目标Pod的负载变化情况，来确定是否需要针对性地调整目标Pod的副本数，这是HPA的实现原理。