架构整洁之道上篇（编程范式&设计原则）

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
//问题：假设我们有一个整数列表，我们要找到这个列表中的偶数，并将它们乘以2，然后将结果打印出来。
//解释：我们使用了Java 8的流API和Lambda表达式。
//首先，我们通过调用stream()方法将列表转换为流。然后，我们使用filter()方法过滤出偶数。在filter()方法中，我们传递了一个Lambda表达式，该表达式接受一个整数参数n，并检查n是否是偶数。接下来，我们使用map()方法将所有偶数乘以2。最后，我们使用collect()方法将结果收集到一个新的列表中，并使用forEach()方法打印每个元素。
public class FunctionalProgrammingExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        List<Integer> evenNumbersDoubled = numbers.stream()
            .filter(n -> n % 2 == 0) // 过滤偶数
            .map(n -> n * 2) // 将偶数乘以2
            .collect(Collectors.toList()); // 收集结果到一个新的列表

        evenNumbersDoubled.forEach(System.out::println); // 打印结果
    }
}

//在这个示例中，我们定义了一个UserService类和一个UserRepository类。UserService类负责处理用户相关的业务逻辑，如获取用户、添加用户、更新用户和删除用户等。UserRepository类负责与数据库交互，包括获取用户、添加用户、更新用户和删除用户等。这样，我们将业务逻辑和数据访问逻辑分开，并将它们分配到不同的类中，从而实现了单一职责原则。
//使用了以下单一职责原则的实现方法：
//1.一个类只负责一项职责：UserService类只负责处理用户相关的业务逻辑，UserRepository类只负责与数据库交互。这样可以使得每个类只负责一项职责，避免了类的职责模糊和不必要的复杂性。
//2.将业务逻辑和数据访问逻辑分开：UserService类和UserRepository类分别处理业务逻辑和数据访问逻辑。这样可以使得每个类的职责更加明确和专一，提高了代码的可读性、可维护性和可扩展性。
//在实现中，我们可以通过将业务逻辑和数据访问逻辑分开来实现单一职责原则；同时，我们还需要考虑类的职责和类的依赖关系，以便更好地组织和管理我们的代码。再者，我们可以将不同职责的代码分开，并将每个职责放在独立的方法中，这样可以使得代码更加简单、易读和易维护。
public class UserService {
    private UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User getUserById(int id) {
        return userRepository.getUserById(id);
    }

    public void addUser(User user) {
        userRepository.addUser(user);
    }

    public void updateUser(User user) {
        userRepository.updateUser(user);
    }

    public void deleteUser(int id) {
        userRepository.deleteUser(id);
    }
}

public class UserRepository {
    private Connection connection;

    public UserRepository(Connection connection) {
        this.connection = connection;
    }

    public User getUserById(int id) {
        // 调用数据库API获取用户信息
        return null;
    }

    public void addUser(User user) {
        // 调用数据库API添加用户信息
    }

    public void updateUser(User user) {
        // 调用数据库API更新用户信息
    }

    public void deleteUser(int id) {
        // 调用数据库API删除用户信息
    }
}

//我们定义了一个Shape接口，它有一个area()方法来计算形状的面积。然后，我们定义了一个Rectangle类和一个Circle类，它们都实现了Shape接口，并分别计算矩形和圆形的面积。最后，我们定义了一个AreaCalculator类，它接受一个Shape数组作为参数，并计算数组中所有形状的总面积。
//使用了以下开闭原则的实现方法：
//1.对扩展开放：我们通过定义Shape接口和Rectangle类和Circle类来实现对扩展开放。如果我们需要添加其他形状，我们只需要实现Shape接口，并创建一个新的类来计算该形状的面积即可。
//2.对修改关闭：我们通过AreaCalculator类来实现对修改关闭。我们不需要修改AreaCalculator类就可以添加新的形状，因为我们已经定义了Shape接口来表示所有形状，并且每个形状都实现了area()方法来计算面积。
//在实现中，我们可以通过定义接口、抽象类和使用基类等方式来实现对扩展开放；同时，我们可以使用策略模式、工厂模式和依赖注入等方式来实现对修改关闭。
public interface Shape {
    double area();
}

public class Rectangle implements Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double area() {
        return width * height;
    }
}

public class Circle implements Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double area() {
        return Math.PI * radius * radius;
    }
}

public class AreaCalculator {
    public double calculateTotalArea(Shape[] shapes) {
        double totalArea = 0;
        for (Shape shape : shapes) {
            totalArea += shape.area();
        }
        return totalArea;
    }
}

//我们定义了一个Rectangle类，它有一个width和一个height属性，以及一个area()方法来计算矩形的面积。然后，我们定义了一个Square类，它继承自Rectangle类，并覆盖了setWidth()和setHeight()方法来确保正方形的宽度和高度相等。这样，我们可以使用Square类来代替Rectangle类，并且不会影响程序的正确性。
//使用了以下里式替换原则的实现方法：
//1.子类可以替换父类：Square类继承自Rectangle类，它可以替换Rectangle类的实例，因为它继承了Rectangle类的所有属性和方法，并且具有与Rectangle类相同的行为。
//2.不会影响程序的正确性：Square类覆盖了setWidth()和setHeight()方法来确保正方形的宽度和高度相等，并且保持了与Rectangle类相同的行为，因此在使用Square类替换Rectangle类时，不会影响程序的正确性。
//在实现中，我们可以通过继承、实现接口和使用抽象类等方式来实现里式替换原则；同时，我们还需要确保子类满足父类的所有行为和属性，并且不会增加或修改父类的行为。
public class Rectangle {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public double area() {
        return width * height;
    }
}

public class Square extends Rectangle {
    public Square(double sideLength) {
        super(sideLength, sideLength);
    }

    public void setWidth(double width) {
        super.setWidth(width);
        super.setHeight(width);
    }

    public void setHeight(double height) {
        super.setWidth(height);
        super.setHeight(height);
    }
}

//我们定义了两个接口Worker和Eater，分别表示工作者和食客。然后，我们定义了一个Programmer类和一个Waiter类，它们都实现了Worker接口，并分别表示程序员和服务员。Waiter类还实现了Eater接口，表示服务员还是一个食客。最后，我们定义了一个Robot类，它也实现了Worker接口，表示机器人也是一个工作者。
//使用了以下接口隔离原则的实现方法：
//1.接口设计精简单一：Worker接口只包含work()方法，Eater接口只包含eat()方法。这样可以使接口设计更加精简，不会包含多余的方法，避免了接口冗余和不必要的复杂性。
//2.类只实现必要的接口：Programmer类只实现Worker接口，Waiter类实现了Worker和Eater接口，Robot类也实现了Worker接口。这样可以使得每个类只实现必要的接口，避免了不必要的依赖和复杂性。
//在实现中，我们可以通过定义精简的接口和让类只实现必要的接口来实现接口隔离原则；同时，我们还需要考虑接口的依赖关系和接口的易用性，以便更好地组织和管理我们的代码。
public interface Worker {
    void work();
}

public interface Eater {
    void eat();
}

public class Programmer implements Worker {
    public void work() {
        System.out.println("Programmer works.");
    }
}

public class Waiter implements Worker, Eater {
    public void work() {
        System.out.println("Waiter works.");
    }

    public void eat() {
        System.out.println("Waiter eats.");
    }
}

public class Robot implements Worker {
    public void work() {
        System.out.println("Robot works.");
    }
}

//在这个示例中，我们定义了一个Animal接口和两个实现类Dog和Cat，它们分别表示狗和猫。然后，我们定义了一个AnimalFeeder类，它依赖于Animal接口，而不是具体的实现类。AnimalFeeder类包含一个构造函数，它接受一个Animal类型的参数，并将它保存在类内部。AnimalFeeder类还有一个feed()方法，它调用了Animal接口的eat()方法来喂养动物。
//使用了以下依赖反转原则的实现方法：
//1.依赖关系建立于抽象而不是具体实现：AnimalFeeder类依赖于Animal接口，而不是具体的实现类。这样可以使得AnimalFeeder类与具体的实现类解耦，从而提高了代码的灵活性、可扩展性和可维护性。
//2.通过构造函数注入依赖：AnimalFeeder类通过构造函数接受一个Animal类型的参数，并将它保存在类内部。这样可以使得依赖关系的建立显式化，同时也可以方便进行依赖注入。
//在实现中，我们可以通过依赖注入和面向接口编程来实现依赖反转原则；同时，我们还需要考虑接口的设计和类的依赖关系，以便更好地组织和管理我们的代码。
public interface Animal {
    void eat();
}

public class Dog implements Animal {
    public void eat() {
        System.out.println("Dog eats bones.");
    }
}

public class Cat implements Animal {
    public void eat() {
        System.out.println("Cat eats fish.");
    }
}

public class AnimalFeeder {
    private Animal animal;

    public AnimalFeeder(Animal animal) {
        this.animal = animal;
    }

    public void feed() {
        animal.eat();
    }
}

//1.构造函数注入: 它通过类的构造函数接受依赖对象，并将其保存在类的成员变量中。
public class UserService {
    private UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // ...
}

//2.Setter方法注入：它通过类的Setter方法接受依赖对象，并将其保存在类的成员变量中。使得依赖注入更加灵活，但也容易导致类的职责模糊和Setter方法的滥用。
public class UserService {
    private UserRepository userRepository;

    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // ...
}

//3.接口注入：它通过一个接口来定义依赖注入的方法，并由类实现该接口。
public interface UserRepositoryAware {
    void setUserRepository(UserRepository userRepository);
}

public class UserService implements UserRepositoryAware {
    private UserRepository userRepository;

    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    // ...
}