当前位置： 首页 > news >正文

设计模式——简单工厂模式（创建型）

news 来源：原创 2025/6/2 18:22:34

摘要

本文主要介绍了简单工厂模式，包括其定义、结构、实现方式、适用场景、实战示例以及思考。简单工厂模式是一种创建型设计模式，通过工厂类根据参数决定创建哪一种产品类的实例，封装了对象创建的细节，使客户端无需关心具体类的创建逻辑。文章详细阐述了其角色组成、类图、时序图，探讨了两种常见的实现方式，分析了适合与不适合的场景，并提供了 Spring 项目和可插拔式策略工厂的实战示例。最后，还提出了支持 SPI 机制、注解标记策略名称和配置中心切换策略等思考方向。

1. 简单工厂模式定义

简单工厂模式是一种创建型设计模式，它通过一个工厂类根据传入的参数决定创建哪一种产品类的实例。

核心要点：

  • 核心角色：工厂类（Factory）
    • 负责创建产品对象。
    • 客户端只需传递参数，不关心具体类的创建逻辑。
  • 目标：封装对象创建的细节，将创建对象的逻辑从使用者中分离出来。

组成结构：

角色

说明

Product

抽象产品类（接口或抽象类）

ConcreteProduct

具体产品类，实现 Product 接口

Factory

工厂类，包含创建产品对象的静态方法

Client

客户端，调用工厂方法获取产品对象并使用它

2. 简单工厂模式结构

2.1. 简单工厂类图

2.2. 简单工厂时序图

3. 简单工厂模式实现方式

实现方式主要分为两种：

实现方式

描述

1. 静态方法创建（常用）

工厂方法是 static的，客户端直接通过类名调用，无需实例化工厂

2. 实例方法创建（灵活）

工厂需要先实例化，再调用方法创建对象，适合支持不同配置或依赖注入

3.1. ✅ 实现方式 1：静态方法创建产品对象（最常见）

// 抽象产品
public interface Product {void doWork();
}// 具体产品 A
public class ProductA implements Product {public void doWork() {System.out.println("产品A正在工作");}
}// 具体产品 B
public class ProductB implements Product {public void doWork() {System.out.println("产品B正在工作");}
}// 简单工厂
public class SimpleFactory {public static Product createProduct(String type) {if ("A".equalsIgnoreCase(type)) {return new ProductA();} else if ("B".equalsIgnoreCase(type)) {return new ProductB();}throw new IllegalArgumentException("不支持的产品类型：" + type);}
}// 客户端
public class Client {public static void main(String[] args) {Product product = SimpleFactory.createProduct("A");product.doWork();  // 输出：产品A正在工作}
}

3.2. ✅ 实现方式 2：使用工厂实例方法创建产品对象（便于配置）

// 工厂类
public class SimpleFactory {public Product createProduct(String type) {if ("A".equalsIgnoreCase(type)) {return new ProductA();} else if ("B".equalsIgnoreCase(type)) {return new ProductB();}throw new IllegalArgumentException("不支持的产品类型：" + type);}
}// 客户端
public class Client {public static void main(String[] args) {SimpleFactory factory = new SimpleFactory();Product product = factory.createProduct("B");product.doWork();  // 输出：产品B正在工作}
}

3.3. 🧠 简单工厂实现总结

对比项

静态方法工厂

实例方法工厂

是否需要工厂对象

否

是

是否支持配置

较差

支持通过构造函数注入

使用场景

通用工厂、工具类

多配置或状态的工厂类

4. 简单工厂模式适合场景

4.1. ✅ 适合的场景（推荐使用简单工厂）：

场景描述

原因

产品种类有限，变化不大

工厂中 if-else/switch 可维护性尚可，结构清晰

客户端不关心对象创建细节

封装了具体类的创建过程，减少耦合

多个子类实现一个接口/抽象类，客户端按条件选择创建哪一个

工厂根据传参决定具体返回哪个子类

代码结构相对简单，开发阶段处于初期

不想引入复杂设计，简单工厂最直观、易懂

希望集中管理对象创建

比 scattered new 更好维护和修改

📌 示例：日志输出、支付方式选择、消息发送器选择（短信/邮件/微信）等。

4.2. ❌ 不适合的场景（不推荐使用简单工厂）：

场景描述

问题

1. 产品种类经常变化或增加

每新增一个产品都要修改工厂类，违反“开放封闭原则”

2. 产品种类太多，逻辑复杂

工厂类会膨胀成一个巨大类，不利于维护

3. 需要依赖注入、构造过程复杂

无法灵活注入依赖，缺乏拓展性

4. 对产品创建过程有定制要求

不能对不同产品的创建过程进行细粒度控制

5. 分布式、多模块开发场景

集中式工厂类会形成模块间强依赖，不利于解耦和部署

📌 示例：大型系统中涉及复杂对象生命周期控制的场景（如数据库连接池、线程池、配置驱动类等）。

4.3. ✅ 使用建议总结：

建议

原因

✔ 使用于产品稳定、变化少的小规模项目

简单、易维护

❌ 不建议用于大型、产品体系复杂的项目

违背开闭原则、扩展性差

👉 可结合工厂方法模式或抽象工厂模式演进

更好地支持扩展与解耦

5. 简单工厂模式实战示例

5.1. Spring项目中简单工厂示例

我们以“消息发送系统”为例，演示如何使用简单工厂根据输入创建不同的消息发送器（如短信、邮件、微信等）。

5.1.1. ✅ 场景目标

在 Spring 项目中，根据配置选择不同的消息发送器进行发送，如：

  • 配置为 sms：发送短信；
  • 配置为 email：发送邮件；
  • 配置为 wechat：发送微信。

5.1.2. ✅ 定义统一接口

public interface MessageSender {void send(String message);
}

5.1.3. ✅ 三种发送器的实现类

@Component("smsSender")
public class SmsSender implements MessageSender {public void send(String message) {System.out.println("发送短信：" + message);}
}@Component("emailSender")
public class EmailSender implements MessageSender {public void send(String message) {System.out.println("发送邮件：" + message);}
}@Component("wechatSender")
public class WechatSender implements MessageSender {public void send(String message) {System.out.println("发送微信：" + message);}
}

5.1.4. ✅ 简单工厂类（使用 Spring 容器管理）

@Component
public class MessageSenderFactory {@Autowiredprivate ApplicationContext applicationContext;public MessageSender createSender(String type) {switch (type.toLowerCase()) {case "sms":return applicationContext.getBean("smsSender", MessageSender.class);case "email":return applicationContext.getBean("emailSender", MessageSender.class);case "wechat":return applicationContext.getBean("wechatSender", MessageSender.class);default:throw new IllegalArgumentException("不支持的消息类型：" + type);}}
}

5.1.5. ✅ 使用示例（Controller 或 Service）

@Service
public class NotifyService {@Autowiredprivate MessageSenderFactory messageSenderFactory;// 模拟从配置文件或参数中读取类型@Value("${message.type:sms}")private String messageType;public void notifyUser(String content) {MessageSender sender = messageSenderFactory.createSender(messageType);sender.send(content);}
}

5.1.6. ✅ 应用入口（或 Controller）

@RestController
public class MessageController {@Autowiredprivate NotifyService notifyService;@GetMapping("/send")public String send(@RequestParam String msg) {notifyService.notifyUser(msg);return "消息已发送";}
}

5.1.7. ✅ application.yml 示例配置

message:type: email

5.1.8. ✅ 简单工厂示例总结

设计点

说明

工厂类

MessageSenderFactory是核心简单工厂类

接口统一

所有发送器实现 MessageSender接口

解耦

NotifyService不依赖具体实现类，依赖工厂和接口

可配置

支持通过配置控制行为，符合 Spring 项目实践

5.2. 可插拔式策略工厂（使用 SPI、Map 注册） 示例

下面是一个 可插拔式策略工厂（基于 Map 注册 + Spring 管理） 的完整示例，非常适用于需要动态切换、按配置扩展的业务策略类，比如：消息发送、支付渠道、风控策略、营销活动处理器等。实现一种 灵活可扩展 的策略选择工厂，每个策略自动注册 到一个 Map<String, Strategy> 中，不需要手动 switch-case。

5.2.1. ✅ 定义统一接口（策略接口）

public interface MessageSender {String type(); // 每个实现类提供自己的标识void send(String message);
}

5.2.2. ✅ 三种发送实现类（@Component 自动注入）

@Component
public class SmsSender implements MessageSender {public String type() {return "sms";}public void send(String message) {System.out.println("【短信】发送：" + message);}
}@Component
public class EmailSender implements MessageSender {public String type() {return "email";}public void send(String message) {System.out.println("【邮件】发送：" + message);}
}@Component
public class WechatSender implements MessageSender {public String type() {return "wechat";}public void send(String message) {System.out.println("【微信】发送：" + message);}
}

5.2.3. ✅ 自动注册策略工厂（Map 注册方式）

@Component
public class MessageSenderFactory {private final Map<String, MessageSender> senderMap = new HashMap<>();// Spring 会自动注入所有 MessageSender 的实现类@Autowiredpublic MessageSenderFactory(List<MessageSender> senders) {for (MessageSender sender : senders) {senderMap.put(sender.type(), sender);}}public MessageSender getSender(String type) {MessageSender sender = senderMap.get(type);if (sender == null) {throw new IllegalArgumentException("不支持的消息类型: " + type);}return sender;}
}

5.2.4. ✅ 使用策略工厂的服务类

@Service
public class NotifyService {@Autowiredprivate MessageSenderFactory messageSenderFactory;public void notifyUser(String type, String content) {MessageSender sender = messageSenderFactory.getSender(type);sender.send(content);}
}

5.2.5. ✅ Controller 示例

@RestController
@RequestMapping("/msg")
public class MessageController {@Autowiredprivate NotifyService notifyService;@GetMapping("/send")public String send(@RequestParam String type, @RequestParam String msg) {notifyService.notifyUser(type, msg);return "消息已发送";}
}

5.2.6. ✅ 示例调用

请求：

GET /msg/send?type=sms&msg=Hello_SMS
GET /msg/send?type=email&msg=Hello_Email
GET /msg/send?type=wechat&msg=Hello_WeChat

输出：

【短信】发送：Hello_SMS
【邮件】发送：Hello_Email
【微信】发送：Hello_WeChat

5.2.7. 🚀 可插拔式策略工厂优势总结

特性

说明

可插拔

新增一个实现类即可生效，无需改动工厂或业务代码

高扩展性

支持多策略、动态注册

易维护

摆脱 if-else / switch

Spring友好

利用 Spring 自动注入 & 生命周期

5.3. 🔌 简单工厂设计模式可拓展方向（高级）

  • 支持 SPI 机制（META-INF/services），用于插件式加载（可用于 jar 扩展、热插拔）；
  • 支持 注解标记策略名称；
  • 支持配置中心切换策略，如使用 @Value("${message.type}") 注入默认策略。

6. 简单工厂模式思考

6.1. 支持 SPI 机制（META-INF/services），用于插件式加载（可用于 jar 扩展、热插拔）；

下面是一个完整的 基于 Java SPI（Service Provider Interface）机制的插件式策略工厂实现示例，它常用于实现模块解耦、可插拔、动态扩展功能。以“消息发送策略”为例，不使用 Spring 注解扫描，而是通过 SPI 机制动态加载所有实现类。

6.1.1. 🧩 定义 SPI 接口（策略接口）

// src/main/java/com/example/spi/MessageSender.java
package com.example.spi;public interface MessageSender {String type();             // 返回类型标识符void send(String message); // 发送消息逻辑
}

6.1.2. 📝 实现类（位于独立模块 / jar 中）

// src/main/java/com/example/impl/SmsSender.java
package com.example.impl;import com.example.spi.MessageSender;public class SmsSender implements MessageSender {@Overridepublic String type() {return "sms";}@Overridepublic void send(String message) {System.out.println("【短信发送】" + message);}
}

6.1.3. 🗂️ 3SPI 注册文件

在 jar 包中的 resources/META-INF/services/ 路径下创建文件：

META-INF/services/com.example.spi.MessageSender

内容如下（每一行一个实现类的全限定名）：

com.example.impl.SmsSender

✅ 当你有多个策略实现时，添加多行即可，如：

com.example.impl.SmsSender
com.example.impl.EmailSender

6.1.4. ⚙️ 工厂类：动态加载所有策略实现

package com.example.factory;import com.example.spi.MessageSender;import java.util.*;public class MessageSenderFactory {private final Map<String, MessageSender> senderMap = new HashMap<>();public MessageSenderFactory() {// 加载spi接口所有接口实现类ServiceLoader<MessageSender> loader = ServiceLoader.load(MessageSender.class);for (MessageSender sender : loader) {senderMap.put(sender.type(), sender);}}public MessageSender getSender(String type) {MessageSender sender = senderMap.get(type);if (sender == null) {throw new IllegalArgumentException("不支持的消息类型: " + type);}return sender;}
}
ServiceLoader<MessageSender> loader = ServiceLoader.load(MessageSender.class);

是 Java 原生 SPI（Service Provider Interface）机制 的核心。它的底层原理其实并不复杂，是通过读取类路径下的 META-INF/services/ 目录下的文件，并利用反射机制加载实现类。以下是 ServiceLoader 的简化执行逻辑：

// 从 META-INF/services/ 下查找接口对应的配置文件
Enumeration<URL> urls = classLoader.getResources("META-INF/services/" + serviceClass.getName());// 读取文件中的类名
BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
String implClassName = reader.readLine();// 通过反射实例化对象
Class<?> clazz = Class.forName(implClassName);
Object instance = clazz.newInstance();

每个实现类会被加载成一个对象，并返回一个延迟加载的迭代器。

6.1.5. 🧪 使用示例（main 方法中调用）

public class Main {public static void main(String[] args) {MessageSenderFactory factory = new MessageSenderFactory();MessageSender sender = factory.getSender("sms");sender.send("Hello SPI!");}
}

6.1.6. 🎯 整体结构

src/
├── main/
│   ├── java/
│   │   ├── com.example.spi/MessageSender.java
│   │   ├── com.example.impl/SmsSender.java
│   │   └── com.example.factory/MessageSenderFactory.java
│   └── resources/
│       └── META-INF/services/com.example.spi.MessageSender

6.1.7. 📌 SPI 模式的优点

优点

说明

插件化、低耦合

实现类可来自外部 jar 包，主程序不需修改

动态扩展能力强

实现类可以热插拔（配合 OSGi、模块系统）

框架内部广泛使用

Dubbo、JDBC、Spring Boot 自动配置（spring.factories）

6.1.8. 🚫 注意事项

  • SPI 默认是懒加载 + 非线程安全（如有并发需求请做好缓存）；
  • IDE 无法提示类名（注册文件中填写错误 IDE 不会报警）；
  • 多个 jar 中存在相同接口实现可能冲突；
  • 如果你使用的是 SpringBoot，推荐改用 Spring 的 SPI（如 spring.factories 或 spring.factories → spring/org.springframework.boot.autoconfigure.EnableAutoConfiguration）机制配合。

6.2. 支持注解标记策略名称

在 策略模式 中，支持通过 注解 来标记每个策略的名称，可以极大提升策略类的可读性和扩展性，尤其适用于 SPI、Map 注册、Spring 容器注册等场景。

  • 多个 MessageSender 策略实现类
  • 每个类通过注解标记其类型名称（如 @MessageType("sms")）
  • 使用 Map 注册所有策略，支持动态获取

6.2.1. ✅ 定义注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MessageType {String value();  // 策略类型标识
}

6.2.2. ✅ 定义接口

public interface MessageSender {void send(String message);
}

6.2.3. ✅ 实现策略类 + 注解标记

@MessageType("sms")
public class SmsSender implements MessageSender {@Overridepublic void send(String message) {System.out.println("发送短信: " + message);}
}@MessageType("email")
public class EmailSender implements MessageSender {@Overridepublic void send(String message) {System.out.println("发送邮件: " + message);}
}

6.2.4. ✅ 自动注册工厂类（注解扫描）

public class MessageSenderFactory {private final Map<String, MessageSender> senderMap = new HashMap<>();public MessageSenderFactory() {// SPI 加载所有 MessageSender 实现类ServiceLoader<MessageSender> loader = ServiceLoader.load(MessageSender.class);for (MessageSender sender : loader) {MessageType annotation = sender.getClass().getAnnotation(MessageType.class);if (annotation != null) {senderMap.put(annotation.value(), sender);}}}public MessageSender getSender(String type) {MessageSender sender = senderMap.get(type);if (sender == null) {throw new IllegalArgumentException("不支持的消息类型: " + type);}return sender;}
}

6.2.5. ✅ 使用示例

public class Main {public static void main(String[] args) {MessageSenderFactory factory = new MessageSenderFactory();factory.getSender("sms").send("验证码123456");factory.getSender("email").send("欢迎邮件");}
}

6.2.6. ✅ 优点

  • 注解直观标记类型，无需硬编码注册
  • 扩展一个新策略只需添加一个类并标注注解
  • 与 ServiceLoader/Spring 配合使用，支持动态发现

6.3. 支持配置中心切换策略，如使用 @Value("${message.type}") 注入默认策略。

你希望实现一种 支持配置中心动态切换策略 的能力，例如通过配置中心的属性（如 Nacos、Apollo、Spring Cloud Config 等）控制当前策略的类型：实现思路（Spring + 注解 + Map 注册 + 配置驱动）

6.3.1. ✅ 定义策略注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MessageType {String value();
}

6.3.2. ✅ 定义通用接口

public interface MessageSender {void send(String message);
}

6.3.3. ✅ 多个策略实现类

@Component
@MessageType("sms")
public class SmsSender implements MessageSender {public void send(String message) {System.out.println("发送短信: " + message);}
}@Component
@MessageType("email")
public class EmailSender implements MessageSender {public void send(String message) {System.out.println("发送邮件: " + message);}
}

6.3.4. ✅ 策略工厂（Spring 容器自动注册 + 配置驱动）

@Component
public class MessageSenderFactory implements InitializingBean {@Value("${message.type:email}")  // 默认email，可由配置中心动态更新private String defaultType;@Autowiredprivate List<MessageSender> senderList;private final Map<String, MessageSender> senderMap = new HashMap<>();@Overridepublic void afterPropertiesSet() {for (MessageSender sender : senderList) {MessageType annotation = sender.getClass().getAnnotation(MessageType.class);if (annotation != null) {senderMap.put(annotation.value(), sender);}}}/** 如果使用默认方式，采用的就是nacos 配置策略*/public MessageSender getSender() {MessageSender sender = senderMap.get(defaultType);if (sender == null) {throw new IllegalArgumentException("未找到对应的策略类型: " + defaultType);}return sender;}/** 使用入参对应的策略*/public MessageSender getSender(String type) {MessageSender sender = senderMap.get(type);if (sender == null) {throw new IllegalArgumentException("未找到对应的策略类型: " + type);}return sender;}
}

6.3.5. ✅ 使用示例

@RestController
public class MessageController {@Autowiredprivate MessageSenderFactory factory;/** 如果使用默认方式，采用的就是nacos配置策略*/@GetMapping("/send")public String send(@RequestParam String msg) {factory.getSender().send(msg);return "消息已发送";}/** 如果使用入参对应方式发送*/@GetMapping("/email/send")public String send(@RequestParam String sendType, @RequestParam String msg) {factory.getSender(sendType).send(msg);return "消息已发送";}
}

6.3.6. ✅ 配置变更如何生效（支持热刷新）？

如果你使用配置中心（如 Nacos），你还可以让 @Value("${message.type}") 自动刷新：

@RefreshScope
@Component
public class MessageSenderFactory implements InitializingBean {...
}

这样，在 Nacos 修改 message.type=email 为 sms，会实时切换策略。

6.3.7. ✅ 总结优势

特性

实现方式

策略标识

注解 @MessageType

扫描所有策略实现

Spring 注入 List<>

配置驱动选择策略

@Value("${message.type}")

动态刷新策略选择

@RefreshScope+ Nacos

6.4. 使用SPI 机制（META-INF/services），用于插件式加载（可用于 jar 扩展、热插拔）；与普通简单工厂方法实现区别？

使用 SPI 机制（META-INF/services） 和 普通简单工厂模式 都是实现“根据类型返回不同实现类”的策略工厂思想，但它们在实现机制、应用场景和扩展性上有很大不同。以下是详细对比和说明：

6.4.1. 🔍 核心区别对比表

项目

SPI机制（ServiceLoader）

简单工厂模式（自己注册/Map）

加载方式

JDK 内置 ServiceLoader

自动发现实现类

自己手动注册，或用注解 + Spring 扫描

实现类注册位置

META-INF/services/接口全类名

代码中通过 Map<String, Object>

是否依赖容器（如Spring）

否（纯 JDK 原生机制）

是（通常依赖 Spring 注入、配置）

扩展性（插件支持）

强，可动态加入 jar 包扩展实现

弱，必须修改代码或重启注册逻辑

热插拔能力

支持（添加 jar 即生效，重启可用）

不支持，必须重启或改代码

类型标识方式

实现类自己定义类型（如 type()方法）

通常用注解或手动 put(key, impl)

适合插件机制

✅ 非常适合

❌ 不适合

使用门槛

中（需要手动写 SPI 配置文件）

低（代码中实现注册）

6.4.2. 🧩 SPI机制（JDK ServiceLoader）工作原理

  • 你要做的：
    1. 定义一个接口，比如：MessageSender
    2. 实现多个类，比如：EmailSender、SmsSender 并实现该接口
    3. 在 resources/META-INF/services/com.example.spi.MessageSender 文件中列出所有实现类的 全限定类名
com.example.sender.EmailSender
com.example.sender.SmsSender
  • 运行时使用 ServiceLoader 自动扫描并实例化：
ServiceLoader<MessageSender> loader = ServiceLoader.load(MessageSender.class);
for (MessageSender sender : loader) {senderMap.put(sender.type(), sender);
}

📦 实现类可以是外部 jar 包，插件式部署。无需改主程序代码。

6.4.3. 🛠️ 简单工厂模式实现方式

实现逻辑通常在代码里“硬编码”注册每种类型与实现类的关系：

public class SenderFactory {private static final Map<String, MessageSender> map = new HashMap<>();static {map.put("email", new EmailSender());map.put("sms", new SmsSender());}public static MessageSender getSender(String type) {return map.get(type);}
}

🧱 实现类和工厂强耦合，新增类型时，必须改代码、重编、重新部署。

6.4.4. 🚦 使用场景对比

场景

建议使用方式

插件式架构，第三方扩展点

✅ 使用 SPI

配置中心控制策略选择

✅ 使用 Spring + Map

内部服务、类型少且固定

✅ 简单工厂

支持 jar 级别热插拔、可拔插插件

✅ SPI + jar 模块化

多环境配置动态选择实现

✅ Spring 结合 @Value

7. 博文参考

  • 1. 简单工厂模式( Simple Factory Pattern ) — Graphic Design Patterns
  • 创建型 - 简单工厂(Simple Factory) | Java 全栈知识体系

相关文章：

  • 免费且好用的PDF水印添加工具
  • Namespace 命名空间的使用
  • PDFGear——完全免费且功能强大的PDF处理软件
  • AI与智能驾驶的关系和原理：技术融合与未来展望-优雅草卓伊凡一、AI大模型基础原理与智能驾驶
  • 经济法-7-上市公司首次发行、配股增发条件
  • org.junit.runners.model.InvalidTestClassError:此类问题的解决
  • 在 ABP VNext 中集成 Serilog：打造可观测、结构化日志系统
  • Python实现P-PSO优化算法优化循环神经网络LSTM回归模型项目实战
  • 【EF Core】 EF Core 批量操作的进化之路——从传统变更跟踪到无跟踪更新
  • 用 Spring Boot 静态资源映射 vs 用 Nginx 提供静态文件服务总结
  • .net Avalonia 在centos部署
  • AR测量工具：精准测量，多功能集成
  • 寒假学习笔记【匠心制作，图文并茂】——1.20拓扑、强连通分量、缩点
  • 深入解析 Dotnet-Boxed.Framework：提升 .NET 开发效率的利器
  • LiquiGen流体导入UE
  • Windows上用FFmpeg推流及拉流的流程概览
  • ASP.NET Core SignalR的基本使用
  • 从零开始的数据结构教程（八）位运算与状态压缩
  • 使用yocto搭建qemuarm64环境
  • 湖北理元理律师事务所：用科学规划重塑债务人生
  • 怎样制作网站二维码/二十条优化
  • 武汉城乡建设网站/济宁seo公司
  • 广州网站开发哪家专业/wix网站制作
  • 做网站时管理员权限的页面/百度推广没有效果怎么办
  • 无锡做网站建设/有哪些搜索引擎
  • 支付网站建设费会计分录/网站软文推广范文