发布于 由admin

Java架构师需要掌握哪些核心技能

Java架构师的角色与职责

Java架构师是软件开发团队中的关键角色，他们不仅负责设计和规划系统的整体架构，还要确保系统在性能、可扩展性、安全性和维护性等方面达到最优。简单来说，Java架构师就像是一个“技术舵手”，他们不仅要了解Java语言本身，还要精通各种相关技术和工具，以便为项目提供最佳的技术解决方案。

那么，Java架构师到底需要做些什么呢？首先，他们需要具备深厚的技术背景，能够理解并应用Java的核心特性，如面向对象编程（OOP）、泛型、多线程等。其次，架构师还需要掌握多种框架和库，如Spring、Hibernate、MyBatis等，这些工具可以帮助开发者更高效地构建复杂的应用程序。除此之外，架构师还需要关注非功能性需求，如性能优化、安全性、可扩展性和容错性，这些都是确保系统稳定运行的关键因素。

在日常工作中，Java架构师不仅仅是写代码的人，他们更多地是在思考如何将业务需求转化为技术实现。这就要求他们具备良好的沟通能力，能够与产品经理、设计师、开发人员和运维团队紧密合作，确保每个环节都能顺利进行。此外，架构师还需要具备一定的领导力，能够在关键时刻做出决策，并带领团队克服技术难题。

总之，Java架构师的职责不仅仅是编写高质量的代码，更重要的是通过合理的架构设计和技术选型，确保项目的成功。接下来，我们将深入探讨Java架构师所需掌握的核心技能，帮助大家更好地理解这一角色的重要性。

1. 深入理解Java核心概念

作为Java架构师，首先要掌握的就是Java语言的核心概念。Java是一门非常成熟的编程语言，拥有丰富的特性和强大的生态系统。因此，深入理解Java的核心概念不仅是编写高质量代码的基础，更是设计高效、可维护系统的关键。下面我们来详细探讨几个重要的Java核心概念。

1.1 面向对象编程（OOP）

面向对象编程（Object-Oriented Programming, OOP）是Java的核心思想之一。它通过类和对象的概念，将现实世界中的实体抽象为代码中的对象，从而使得代码更加模块化、易于维护和扩展。OOP的四大基本特性包括：

  • 封装（Encapsulation）：封装是指将数据和操作数据的方法绑定在一起，并对外部隐藏实现细节。通过封装，我们可以保护对象的内部状态，防止外部直接访问或修改。例如，使用private修饰符可以限制类的某些属性或方法只能在类内部访问。

    public class User {
  private String name;
  private int age;

  // Getter and Setter methods
  public String getName() {
      return name;
  }

  public void setName(String name) {
      this.name = name;
  }

  public int getAge() {
      return age;
  }

  public void setAge(int age) {
      if (age > 0) {
          this.age = age;
      }
  }
}

  • 继承（Inheritance）：继承允许一个类从另一个类中继承属性和方法，从而实现代码复用。子类可以继承父类的所有非私有成员，并且可以根据需要重写或扩展父类的功能。通过继承，我们可以构建出层次化的类结构，提高代码的可读性和可维护性。

    class Animal {
  public void eat() {
      System.out.println("This animal is eating.");
  }
}

class Dog extends Animal {
  @Override
  public void eat() {
      System.out.println("The dog is eating dog food.");
  }

  public void bark() {
      System.out.println("The dog is barking.");
  }
}

  • 多态（Polymorphism）：多态是指同一个接口或方法可以有不同的实现形式。通过多态，我们可以在不改变调用代码的情况下，动态地选择不同的实现方式。多态通常通过方法重载（Overloading）和方法重写（Overriding）来实现。

    class Shape {
  public void draw() {
      System.out.println("Drawing a shape.");
  }
}

class Circle extends Shape {
  @Override
  public void draw() {
      System.out.println("Drawing a circle.");
  }
}

class Rectangle extends Shape {
  @Override
  public void draw() {
      System.out.println("Drawing a rectangle.");
  }
}

public class TestPolymorphism {
  public static void main(String[] args) {
      Shape shape1 = new Circle();
      Shape shape2 = new Rectangle();

      shape1.draw();  // Output: Drawing a circle.
      shape2.draw();  // Output: Drawing a rectangle.
  }
}

  • 抽象（Abstraction）：抽象是指将复杂的系统简化为一组易于理解和使用的接口。通过抽象，我们可以隐藏复杂的实现细节，只暴露必要的功能给用户。Java中的抽象类和接口是实现抽象的主要方式。

    abstract class Vehicle {
  public abstract void start();
  public void stop() {
      System.out.println("Vehicle stopped.");
  }
}

class Car extends Vehicle {
  @Override
  public void start() {
      System.out.println("Car started.");
  }
}

interface Flyable {
  void fly();
}

class Airplane implements Flyable {
  @Override
  public void fly() {
      System.out.println("Airplane is flying.");
  }
}

1.2 泛型（Generics）

泛型是Java 5引入的一个重要特性，它允许我们在定义类、接口和方法时使用类型参数，从而使代码更加灵活和通用。通过泛型，我们可以编写出适用于多种类型的代码，而不需要为每种类型都编写单独的实现。

class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

public class TestGenerics {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.setContent("Hello, World!");
        System.out.println(stringBox.getContent());  // Output: Hello, World!

        Box<Integer> integerBox = new Box<>();
        integerBox.setContent(42);
        System.out.println(integerBox.getContent());  // Output: 42
    }
}

泛型不仅可以用于类和接口，还可以用于方法。通过泛型方法，我们可以在方法签名中指定类型参数，从而使方法能够处理不同类型的参数。

public class Utility {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }
}

public class TestGenericMethod {
    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] stringArray = {"Apple", "Banana", "Orange"};

        Utility.printArray(intArray);  // Output: 1 2 3 4 5
        Utility.printArray(stringArray);  // Output: Apple Banana Orange
    }
}

1.3 多线程与并发编程

多线程和并发编程是Java中非常重要的一部分，尤其是在处理高性能、高并发的应用场景时。Java提供了丰富的API来支持多线程编程，如Thread类、Runnable接口、Executor框架等。通过合理使用多线程，我们可以充分利用多核处理器的性能，提升应用程序的响应速度和吞吐量。

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread is running.");
    }
}

public class TestThread {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();  // Output: Thread is running.
    }
}

除了传统的Thread类，Java还提供了Runnable接口，允许我们将任务封装为独立的对象，然后将其传递给线程执行。这种方式更加灵活，适合复杂的多线程应用场景。

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable task is running.");
    }
}

public class TestRunnable {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();  // Output: Runnable task is running.
    }
}

为了简化多线程编程，Java还引入了Executor框架，它提供了一组高级API来管理线程池和任务调度。通过使用ExecutorService，我们可以轻松地创建和管理线程池，而无需手动创建和销毁线程。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class Task implements Runnable {
    private final String name;

    public Task(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println("Executing task: " + name);
    }
}

public class TestExecutor {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        executor.submit(new Task("Task 1"));
        executor.submit(new Task("Task 2"));
        executor.submit(new Task("Task 3"));

        executor.shutdown();
    }
}

1.4 异常处理

异常处理是Java中不可或缺的一部分，它允许我们在程序运行过程中捕获和处理错误，从而避免程序崩溃。Java提供了try-catch-finally语句来处理异常，其中try块用于包含可能抛出异常的代码，catch块用于捕获并处理特定类型的异常，finally块则用于执行无论是否发生异常都需要执行的代码。

public class TestExceptionHandling {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;  // This will throw an ArithmeticException
        } catch (ArithmeticException e) {
            System.out.println("Caught an exception: " + e.getMessage());
        } finally {
            System.out.println("Finally block executed.");
        }
    }
}

Java还支持自定义异常，通过继承Exception类或其子类，我们可以创建自己的异常类型，以便更精确地描述和处理特定的错误情况。

class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

public class TestCustomException {
    public static void main(String[] args) {
        try {
            throw new CustomException("This is a custom exception.");
        } catch (CustomException e) {
            System.out.println("Caught a custom exception: " + e.getMessage());
        }
    }
}

1.5 反射（Reflection）

反射是Java中的一项强大特性，它允许我们在运行时动态地获取类的信息，并调用类的方法、访问类的属性等。通过反射，我们可以编写出更加灵活和通用的代码，尤其是在框架开发中，反射被广泛应用。

import java.lang.reflect.Method;

public class TestReflection {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = String.class;
        Object obj = clazz.getDeclaredConstructor().newInstance();

        Method method = clazz.getMethod("toUpperCase");
        String result = (String) method.invoke(obj, "hello");
        System.out.println(result);  // Output: HELLO
    }
}

虽然反射非常强大，但它也有一些缺点，比如性能开销较大、破坏了编译时的类型检查等。因此，在实际开发中，我们应该谨慎使用反射，尽量避免滥用。

2. 掌握常用的设计模式

设计模式是解决常见问题的最佳实践，它们提供了一套经过验证的解决方案，帮助我们设计出更加灵活、可扩展和可维护的系统。作为Java架构师，掌握常用的设计模式是非常重要的。下面我们将介绍几种常见的设计模式及其应用场景。

2.1 单例模式（Singleton Pattern）

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点。单例模式通常用于需要全局共享资源的场景，如数据库连接池、日志记录器等。

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

2.2 工厂模式（Factory Pattern）

工厂模式是一种创建型设计模式，它提供了一种创建对象的接口，但由子类决定实例化哪一个类。工厂模式可以将对象的创建过程与使用过程分离，从而提高代码的灵活性和可扩展性。

interface Product {
    void use();
}

class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using Product A.");
    }
}

class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using Product B.");
    }
}

abstract class Factory {
    public abstract Product createProduct();
}

class ConcreteFactoryA extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

class ConcreteFactoryB extends Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

public class TestFactory {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use();  // Output: Using Product A.

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use();  // Output: Using Product B.
    }
}

2.3 观察者模式（Observer Pattern）

观察者模式是一种行为型设计模式，它定义了一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖于它的对象都会收到通知并自动更新。观察者模式常用于事件驱动的系统，如GUI应用程序、消息队列等。

interface Observer {
    void update(String message);
}

interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers(String message);
}

class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name + " received message: " + message);
    }
}

public class TestObserver {
    public static void main(String[] args) {
        Subject subject = new ConcreteSubject();
        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");

        subject.registerObserver(observer1);
        subject.registerObserver(observer2);

        subject.notifyObservers("Hello, Observers!");  // Output: Observer 1 received message: Hello, Observers! Observer 2 received message: Hello, Observers!
    }
}

2.4 装饰者模式（Decorator Pattern）

装饰者模式是一种结构型设计模式，它允许我们在不改变原有类的基础上，动态地为对象添加新的功能。装饰者模式常用于需要扩展功能的场景，如日志记录、权限控制等。

interface Component {
    void operation();
}

class ConcreteComponent implements Component {
    @Override
    public void operation() {
        System.out.println("ConcreteComponent operation.");
    }
}

class Decorator implements Component {
    protected Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        component.operation();
    }
}

class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        addBehavior();
    }

    private void addBehavior() {
        System.out.println("Added behavior by ConcreteDecoratorA.");
    }
}

class ConcreteDecoratorB extends Decorator {
    public ConcreteDecoratorB(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        addBehavior();
    }

    private void addBehavior() {
        System.out.println("Added behavior by ConcreteDecoratorB.");
    }
}

public class TestDecorator {
    public static void main(String[] args) {
        Component component = new ConcreteComponent();
        Component decoratedComponent = new ConcreteDecoratorA(new ConcreteDecoratorB(component));

        decoratedComponent.operation();
        // Output: ConcreteComponent operation. Added behavior by ConcreteDecoratorB. Added behavior by ConcreteDecoratorA.
    }
}

3. 熟悉主流的Java框架

Java生态系统中有许多优秀的框架，它们可以帮助我们更高效地开发应用程序。作为Java架构师，熟悉这些框架是非常重要的。下面我们来介绍几个常用的Java框架及其应用场景。

3.1 Spring Framework

Spring框架是Java企业级开发中最流行的框架之一，它提供了一系列轻量级的组件和服务，帮助开发者构建健壮、可扩展的企业级应用。Spring的核心特性包括依赖注入（Dependency Injection, DI）、面向切面编程（Aspect-Oriented Programming, AOP）、事务管理等。

<!-- Spring configuration file -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="userService" class="com.example.UserService">
        <property name="userRepository" ref="userRepository"/>
    </bean>

    <bean id="userRepository" class="com.example.UserRepository"/>
</beans>

Spring还提供了Spring Boot，这是一个基于Spring的微服务框架，它简化了Spring应用的配置和部署，使得开发者可以快速启动和运行应用程序。

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

3.2 Hibernate

Hibernate是一个开源的对象关系映射（Object-Relational Mapping, ORM）框架，它允许我们通过Java对象来操作关系型数据库，而无需编写复杂的SQL语句。Hibernate提供了丰富的API来管理数据库连接、执行查询、处理事务等。

// Hibernate configuration file (hibernate.cfg.xml)
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mydb</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <mapping class="com.example.User"/>
    </session-factory>
</hibernate-configuration>
// User entity class
@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "name")
    private String name;

    @Column(name = "email")
    private String email;

    // Getters and setters
}
// DAO class for user operations
@Repository
public class UserDao {
    @Autowired
    private SessionFactory sessionFactory;

    public void saveUser(User user) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        session.save(user);
        transaction.commit();
        session.close();
    }

    public User getUserById(Long id) {
        Session session = sessionFactory.openSession();
        User user = session.get(User.class, id);
        session.close();
        return user;
    }
}

3.3 MyBatis

MyBatis是一个轻量级的ORM框架，它通过XML或注解的方式将SQL语句映射到Java对象上，从而实现数据库操作。相比于Hibernate，MyBatis更加灵活，允许开发者编写自定义的SQL语句，同时也提供了简单的CRUD操作。

<!-- MyBatis configuration file (mybatis-config.xml) -->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
                <property name="username" value="root"/>
                <property name="password" value="password"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/example/UserMapper.xml"/>
    </mappers>
</configuration>
<!-- UserMapper.xml -->
<mapper namespace="com.example.UserMapper">
    <select id="getUserById" parameterType="long" resultType="com.example.User">
        SELECT * FROM users WHERE id = #{id}
    </select>

    <insert id="saveUser" parameterType="com.example.User">
        INSERT INTO users (name, email) VALUES (#{name}, #{email})
    </insert>
</mapper>
// UserMapper interface
public interface UserMapper {
    User getUserById(Long id);
    void saveUser(User user);
}
// DAO class for user operations
@Repository
public class UserDao {
    @Autowired
    private UserMapper userMapper;

    public User getUserById(Long id) {
        return userMapper.getUserById(id);
    }

    public void saveUser(User user) {
        userMapper.saveUser(user);
    }
}

3.4 Apache Kafka

Apache Kafka是一个分布式流处理平台，它允许我们实时处理大规模的数据流。Kafka广泛应用于日志收集、消息队列、实时分析等领域。作为Java架构师，掌握Kafka的基本概念和使用方法是非常有帮助的。

// Kafka producer example
Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

Producer<String, String> producer = new KafkaProducer<>(props);
producer.send(new ProducerRecord<>("my-topic", "key", "value"));
producer.close();
// Kafka consumer example
Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("group.id", "test-group");
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

Consumer<String, String> consumer = new KafkaConsumer<>(props);
consumer.subscribe(Collections.singletonList("my-topic"));

while (true) {
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
    for (ConsumerRecord<String, String> record : records) {
        System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
    }
}

4. 关注非功能性需求

除了掌握核心技术，Java架构师还需要关注一些非功能性需求，如性能优化、安全性、可扩展性和容错性。这些需求虽然不像功能需求那样直观，但它们对系统的稳定性和用户体验有着至关重要的影响。

4.1 性能优化

性能优化是Java架构师的重要职责之一。通过对代码进行优化，我们可以提高系统的响应速度和吞吐量，减少资源消耗。常见的性能优化手段包括：

  • 缓存：使用缓存可以减少数据库查询次数，提升系统的响应速度。常见的缓存技术包括内存缓存（如Ehcache、Guava Cache）和分布式缓存（如Redis、Memcached）。

  • 异步处理：通过异步处理，我们可以将耗时的操作放到后台执行，避免阻塞主线程。Java提供了CompletableFuture、ExecutorService等API来实现异步编程。

  • 批量处理：对于频繁的数据库操作，可以通过批量处理来减少数据库连接的开销。例如，使用Hibernate的批量插入功能可以显著提高性能。

  • 数据库优化：通过优化数据库索引、查询语句和表结构，可以大幅提升数据库的查询效率。常见的优化手段包括添加索引、分库分表、使用NoSQL数据库等。

4.2 安全性

安全性是任何系统都必须考虑的问题。作为Java架构师，我们需要确保系统的安全性，防止恶意攻击和数据泄露。常见的安全措施包括：

  • 身份验证和授权：通过用户名密码、OAuth、JWT等方式实现用户的身份验证和授权，确保只有合法用户才能访问系统资源。

  • 输入验证：对用户输入的数据进行严格的验证，防止SQL注入、XSS攻击等常见的安全漏洞。

  • 加密：对敏感数据进行加密存储和传输，确保数据的安全性。常见的加密算法包括AES、RSA、SHA等。

  • 日志审计：记录系统的关键操作日志，便于后续的安全审计和问题排查。

4.3 可扩展性

随着业务的增长，系统的负载会不断增加，因此我们需要设计一个具有良好扩展性的架构，以应对未来的扩展需求。常见的扩展策略包括：

  • 水平扩展：通过增加服务器节点来提升系统的处理能力。常见的水平扩展方式包括负载均衡、集群部署等。

  • 垂直扩展：通过升级硬件设备（如CPU、内存、磁盘）来提升系统的性能。垂直扩展适用于小型系统，但对于大型系统来说，水平扩展更为有效。

  • 微服务架构：将单体应用拆分为多个独立的服务，每个服务都可以独立部署和扩展。微服务架构可以提高系统的灵活性和可维护性，但也带来了复杂性，如服务间的通信、分布式事务等。

4.4 容错性

容错性是指系统在遇到故障时能够自动恢复的能力。作为Java架构师，我们需要设计一个具有高容错性的系统，确保即使某个组件出现故障，整个系统仍然能够正常运行。常见的容错机制包括：

  • 冗余设计：通过冗余设计，确保系统中的关键组件有多个副本，避免单点故障。例如，使用主从数据库、双机热备等技术。

  • 熔断机制：当某个服务出现故障时，熔断机制可以暂时停止对该服务的调用，避免故障扩散。常见的熔断框架包括Hystrix、Resilience4j等。

  • 重试机制：当某个操作失败时，重试机制可以自动重新执行该操作，直到成功为止。重试机制可以提高系统的可靠性，但也需要注意避免无限重试导致资源浪费。

  • 限流机制：当系统的负载过高时，限流机制可以限制请求的频率，防止系统过载。常见的限流算法包括令牌桶、漏桶等。

5. 结语

作为一名Java架构师，掌握核心技术、设计模式、常用框架以及非功能性需求是非常重要的。通过不断学习和实践，我们可以设计出更加高效、稳定和可扩展的系统，帮助企业在激烈的市场竞争中脱颖而出。希望本文能够为大家提供一些有价值的参考，祝大家在Java架构师的道路上越走越远！

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注