Refresh your Java skills--聊聊Java9 中模块化设计是如何实现相似IOC依赖注入效果及与其区别
场景引入
如何实现IOC的效果，咱们能够来想一想，无非就是一个隐式实现，而想要作到，总不能什么都没有，来个巧妇难为无米之炊的境地吧，因此说，米必需要有滴，在Spring中就是一个bean，也就是说，容器里得有米，再官话点就是上下文中得存在所须要的bean。一样模块化中两个互相隔离的模块想要达到这种效果，也要先往jvm里扔个对象进去的，而后who use ，who get 就能够了。java
请看例子(能够认为是咱们日常写的SpringMVC项目中的service->serviceImpl->controller):api
service接口化模块
package com.example.api;
public interface CodecFactory {
Encoder getEncoder(String encodingName);
Decoder getDecoder(String encodingName);
}复制代码
上面这个接口所在的模块定义:app
module migo.codec.api {
exports com.example.api;
}复制代码
serviceImpl化模块
接着，咱们定义一个实现模块:jvm
module migo.codec.service {
requires com.example.api;
provides com.example.api.CodecFactory with com.example.service.codec.CodecFactoryImpl;
}复制代码
具体实现就省略了。ide
controller化模块
最后咱们在最上层的模块内使用:模块化
module migo.codec.controller {
requires migo.codec.api;
uses com.example.api.CodecFactory;
}复制代码
具体的controller模块内使用的代码以下:函数
ServiceLoader<CodecFactory> loader = ServiceLoader.load(CodecFactory.class);
for (CodecFactory factory : loader) {
Encoder enc = factory.getEncoder("PNG");
if (enc != null)
... use enc to encode a PNG file
break;
}复制代码
或者:ui
public static void main(String... args) {
CodecFactory cf =
ServiceLoader.load(CodecFactory.class)
.findFirst()
.orElse(getFallBack());
if(cf == null) {
System.out.println("Using a fallback");
} else {
System.out.println("Found a service");
}
}
private static CodecFactory getFallBack() {
return null;
}复制代码
亦或者假若有不少服务实现的提供者，而某个提供服务实现的provider(也就是serviceImpl)上面有添加注解@PNG，而咱们想使用带有这个注解的实例，可使用如下代码:this
ServiceLoader<CodecFactory> loader = ServiceLoader.load(CodecFactory.class);
Set<CodecFactory> pngFactories = loader
.stream()
.filter(p -> p.type().isAnnotationPresent(PNG.class))
.map(Provider::get)
.collect(Collectors.toSet());复制代码
内部工做机制原理
具体思路:
经过在模块定义里面的provides aaa with aaaImpl 这个功能，能够很容易的想到key value组合
当咱们碰到这对关键字的时候，咱们就会解析并将aaa作为key，aaaImpl添加到一个list中并将这个list做为value，并添加到一个Map<String,list>中
在咱们碰到uses关键字（源码里面acc会去肯定这个权限），并经过ServiceLoader.load(key)来找到这个key所对应的一个包含了实现类具体地址的list，可能有多个，那么，拓展功能，咱们使用一个装饰模式，也就是继承了Iterable这个接口，能够达到遍历并生成具体实例来达到要求。spa
源码解析
肯定米粒的路径
那么按照这个思路，咱们反着来找下，这里只列关键代码:
从上面的Demo中，咱们能够看到，经过类的class字节码来加载:
以前有说，巧妇难为无米之炊，因此这个上下文很重要，咱们的类加载器也是要讲究上下文的
/** * Creates a new service loader for the given service type, using the * current thread's {@linkplain java.lang.Thread#getContextClassLoader * context class loader}. * * <p> An invocation of this convenience method of the form * <pre>{@code * ServiceLoader.load(service) * }</pre> * * is equivalent to * * <pre>{@code * ServiceLoader.load(service, Thread.currentThread().getContextClassLoader()) * }</pre> * * @apiNote Service loader objects obtained with this method should not be * cached VM-wide. For example, different applications in the same VM may * have different thread context class loaders. A lookup by one application * may locate a service provider that is only visible via its thread * context class loader and so is not suitable to be located by the other * application. Memory leaks can also arise. A thread local may be suited * to some applications. * * @param <S> the class of the service type * * @param service * The interface or abstract class representing the service * * @return A new service loader * * @throws ServiceConfigurationError * if the service type is not accessible to the caller or the * caller is in an explicit module and its module descriptor does * not declare that it uses {@code service} * * @revised 9 * @spec JPMS */
@CallerSensitive
public static <S> ServiceLoader<S> load(Class<S> service) {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
return new ServiceLoader<>(Reflection.getCallerClass(), service, cl);
}复制代码
咱们进去这个ServiceLoader，其实无非就是一个构造器而已了，关键代码我截下:
this.service = svc;
this.serviceName = svc.getName();
this.layer = null;
this.loader = cl;
this.acc = (System.getSecurityManager() != null)
? AccessController.getContext()
: null;复制代码
有了这个加载器以后，其实咱们就拿到了上下文和访问权限的一些东西，咱们再来看看这个类的字段：
public final class ServiceLoader<S> implements Iterable<S> {
// The class or interface representing the service being loaded
private final Class<S> service;
// The class of the service type
private final String serviceName;
// The module layer used to locate providers; null when locating
// providers using a class loader
private final ModuleLayer layer;
// The class loader used to locate, load, and instantiate providers;
// null when locating provider using a module layer
private final ClassLoader loader;
// The access control context taken when the ServiceLoader is created
private final AccessControlContext acc;
// The lazy-lookup iterator for iterator operations
private Iterator<Provider<S>> lookupIterator1;
private final List<S> instantiatedProviders = new ArrayList<>();
// The lazy-lookup iterator for stream operations
private Iterator<Provider<S>> lookupIterator2;
private final List<Provider<S>> loadedProviders = new ArrayList<>();
private boolean loadedAllProviders; // true when all providers loaded
// Incremented when reload is called
private int reloadCount;
private static JavaLangAccess LANG_ACCESS;复制代码
能够看到，它实现了按照咱们分析的Iterable接口，这样咱们就能够多了不少操做，并且咱们也看到了下面这几个东西，这样咱们就能够作事情了:
private Iterator<Provider<S>> lookupIterator2;
private final List<Provider<S>> loadedProviders = new ArrayList<>();
private boolean loadedAllProviders; // true when all providers loaded复制代码
咱们走进findFirst这个方法来看看:
public Optional<S> findFirst() {
Iterator<S> iterator = iterator();
if (iterator.hasNext()) {
return Optional.of(iterator.next());
} else {
return Optional.empty();
}
}复制代码
咱们看到了iterator()这个方法:
public Iterator<S> iterator() {
// create lookup iterator if needed
if (lookupIterator1 == null) {
lookupIterator1 = newLookupIterator();
}
return new Iterator<S>() {
// record reload count
final int expectedReloadCount = ServiceLoader.this.reloadCount;
...
}复制代码
如今newLookupIterator()进入到咱们的视野中，没有条件建立条件，刚开始咱们可没有拿到米，如今去找米去:
/** * Returns a new lookup iterator. */
private Iterator<Provider<S>> newLookupIterator() {
assert layer == null || loader == null;
if (layer != null) {
return new LayerLookupIterator<>();
} else {
Iterator<Provider<S>> first = new ModuleServicesLookupIterator<>();
Iterator<Provider<S>> second = new LazyClassPathLookupIterator<>();
return new Iterator<Provider<S>>() {
@Override
public boolean hasNext() {
return (first.hasNext() || second.hasNext());
}
@Override
public Provider<S> next() {
if (first.hasNext()) {
return first.next();
} else if (second.hasNext()) {
return second.next();
} else {
throw new NoSuchElementException();
}
}
};
}
}复制代码
这里抛开其余咱们来看ModuleServicesLookupIterator()这个构造函数 ：
ModuleServicesLookupIterator() {
this.currentLoader = loader;
this.iterator = iteratorFor(loader);
}复制代码
映入眼帘的是iteratorFor(ClassLoader loader)这个方法:
/** * Returns an iterator to iterate over the implementations of {@code * service} in modules defined to the given class loader or in custom * layers with a module defined to this class loader. */
private Iterator<ServiceProvider> iteratorFor(ClassLoader loader) {
// modules defined to the class loader
ServicesCatalog catalog;
if (loader == null) {
catalog = BootLoader.getServicesCatalog();
} else {
catalog = ServicesCatalog.getServicesCatalogOrNull(loader);
}
//此处往下到我中文标记结束就是咱们的正主了
List<ServiceProvider> providers;
if (catalog == null) {
providers = List.of();
} else {
providers = catalog.findServices(serviceName);
}
//结束
// modules in layers that define modules to the class loader
ClassLoader platformClassLoader = ClassLoaders.platformClassLoader();
if (loader == null || loader == platformClassLoader) {
return providers.iterator();
} else {
List<ServiceProvider> allProviders = new ArrayList<>(providers);
Iterator<ModuleLayer> iterator = LANG_ACCESS.layers(loader).iterator();
while (iterator.hasNext()) {
ModuleLayer layer = iterator.next();
for (ServiceProvider sp : providers(layer)) {
ClassLoader l = loaderFor(sp.module());
if (l != null && l != platformClassLoader) {
allProviders.add(sp);
}
}
}
return allProviders.iterator();
}
}复制代码
这里终于找到了findServices(String service)这个方法:
/** * Returns the (possibly empty) list of service providers that implement * the given service type. */
public List<ServiceProvider> findServices(String service) {
return map.getOrDefault(service, Collections.emptyList());
}复制代码
结合getOrDefault的源码可知:
default V getOrDefault(Object key, V defaultValue) {
V v;
return (((v = get(key)) != null) || containsKey(key))
? v
: defaultValue;
}复制代码
是否是和咱们的具体思路接上轨了
拿到咱们想要的大米
而咱们的provider实例从何而来，请容我娓娓道来咯：
咱们从jdk.internal.module.Modules这个模块定义类中能够找到addProvides这个方法，也就是说在咱们加载这个模块的时候，这个动做就已经要干活了:
/** * Updates module m to provide a service */
public static void addProvides(Module m, Class<?> service, Class<?> impl) {
ModuleLayer layer = m.getLayer();
PrivilegedAction<ClassLoader> pa = m::getClassLoader;
ClassLoader loader = AccessController.doPrivileged(pa);
ClassLoader platformClassLoader = ClassLoaders.platformClassLoader();
if (layer == null || loader == null || loader == platformClassLoader) {
// update ClassLoader catalog
ServicesCatalog catalog;
if (loader == null) {
catalog = BootLoader.getServicesCatalog();
} else {
catalog = ServicesCatalog.getServicesCatalog(loader);
}
catalog.addProvider(m, service, impl);
}
if (layer != null) {
// update Layer catalog
JLA.getServicesCatalog(layer).addProvider(m, service, impl);
}
}复制代码
而后咱们能够从sun.instrument.InstrumentationImpl这个类来看到其工做方式(经过其注释就能够看到这个类和JVM相关):
在加载模块的时候就执行了下面的代码，看下面update provides这个注释的代码能够知道其调用了上面的addProvides这个方法，而最后也是调用了addProvider(m, service, impl)
/** * The Java side of the JPLIS implementation. Works in concert with a native JVMTI agent * to implement the JPLIS API set. Provides both the Java API implementation of * the Instrumentation interface and utility Java routines to support the native code. * Keeps a pointer to the native data structure in a scalar field to allow native * processing behind native methods. */
public class InstrumentationImpl implements Instrumentation {
...
@Override
public void redefineModule(Module module, Set<Module> extraReads, Map<String, Set<Module>> extraExports, Map<String, Set<Module>> extraOpens, Set<Class<?>> extraUses, Map<Class<?>, List<Class<?>>> extraProvides) {
if (!module.isNamed())
return;
if (!isModifiableModule(module))
throw new UnmodifiableModuleException(module.getName());
// copy and check reads
extraReads = new HashSet<>(extraReads);
if (extraReads.contains(null))
throw new NullPointerException("'extraReads' contains null");
// copy and check exports and opens
extraExports = cloneAndCheckMap(module, extraExports);
extraOpens = cloneAndCheckMap(module, extraOpens);
// copy and check uses
extraUses = new HashSet<>(extraUses);
if (extraUses.contains(null))
throw new NullPointerException("'extraUses' contains null");
// copy and check provides
Map<Class<?>, List<Class<?>>> tmpProvides = new HashMap<>();
for (Map.Entry<Class<?>, List<Class<?>>> e : extraProvides.entrySet()) {
Class<?> service = e.getKey();
if (service == null)
throw new NullPointerException("'extraProvides' contains null");
List<Class<?>> providers = new ArrayList<>(e.getValue());
if (providers.isEmpty())
throw new IllegalArgumentException("list of providers is empty");
providers.forEach(p -> {
if (p.getModule() != module)
throw new IllegalArgumentException(p + " not in " + module);
if (!service.isAssignableFrom(p))
throw new IllegalArgumentException(p + " is not a " + service);
});
tmpProvides.put(service, providers);
}
extraProvides = tmpProvides;
// update reads
extraReads.forEach(m -> Modules.addReads(module, m));
// update exports
for (Map.Entry<String, Set<Module>> e : extraExports.entrySet()) {
String pkg = e.getKey();
Set<Module> targets = e.getValue();
targets.forEach(m -> Modules.addExports(module, pkg, m));
}
// update opens
for (Map.Entry<String, Set<Module>> e : extraOpens.entrySet()) {
String pkg = e.getKey();
Set<Module> targets = e.getValue();
targets.forEach(m -> Modules.addOpens(module, pkg, m));
}
// update uses
extraUses.forEach(service -> Modules.addUses(module, service));
// update provides
for (Map.Entry<Class<?>, List<Class<?>>> e : extraProvides.entrySet()) {
Class<?> service = e.getKey();
List<Class<?>> providers = e.getValue();
providers.forEach(p -> Modules.addProvides(module, service, p));
}
}
...
}复制代码
Instrumentation接口有一段很重要的注释，你们本身看吧，就很少说了:
/** * This class provides services needed to instrument Java * programming language code. * Instrumentation is the addition of byte-codes to methods for the * purpose of gathering data to be utilized by tools. * Since the changes are purely additive, these tools do not modify * application state or behavior. * Examples of such benign tools include monitoring agents, profilers, * coverage analyzers, and event loggers. * * <P> * There are two ways to obtain an instance of the * <code>Instrumentation</code> interface: * * <ol> * <li><p> When a JVM is launched in a way that indicates an agent * class. In that case an <code>Instrumentation</code> instance * is passed to the <code>premain</code> method of the agent class. * </p></li> * <li><p> When a JVM provides a mechanism to start agents sometime * after the JVM is launched. In that case an <code>Instrumentation</code> * instance is passed to the <code>agentmain</code> method of the * agent code. </p> </li> * </ol> * <p> * These mechanisms are described in the * {@linkplain java.lang.instrument package specification}. * <p> * Once an agent acquires an <code>Instrumentation</code> instance, * the agent may call methods on the instance at any time. * * @since 1.5 */
public interface Instrumentation {
}复制代码
那么，咱们最后，走入addProvider(m, service, impl)这个方法中:
/** * Add a provider in the given module to this services catalog * * @apiNote This method is for use by java.lang.instrument */
public void addProvider(Module module, Class<?> service, Class<?> impl) {
List<ServiceProvider> list = providers(service.getName());
list.add(new ServiceProvider(module, impl.getName()));
}
...
public final class ServiceProvider {
private final Module module;
private final String providerName;
public ServiceProvider(Module module, String providerName) {
this.module = module;
this.providerName = providerName;
}
...
}复制代码
再通过了这么曲曲折折的过程，终于拿到了ServiceProvider,里面包括了咱们所要调用实现类的地址信息
因而，看下ServiceLoader这个类定义的Provider静态内部接口：
/** * Represents a service provider located by {@code ServiceLoader}. * * <p> When using a loader's {@link ServiceLoader#stream() stream()} method * then the elements are of type {@code Provider}. This allows processing * to select or filter on the provider class without instantiating the * provider. </p> * * @param <S> The service type * @since 9 * @spec JPMS */
public static interface Provider<S> extends Supplier<S> {
/** * Returns the provider type. There is no guarantee that this type is * accessible or that it has a public no-args constructor. The {@link * #get() get()} method should be used to obtain the provider instance. * * <p> When a module declares that the provider class is created by a * provider factory then this method returns the return type of its * public static "{@code provider()}" method. * * @return The provider type */
Class<? extends S> type();
/** * Returns an instance of the provider. * * @return An instance of the provider. * * @throws ServiceConfigurationError * If the service provider cannot be instantiated, or in the * case of a provider factory, the public static * "{@code provider()}" method returns {@code null} or throws * an error or exception. The {@code ServiceConfigurationError} * will carry an appropriate cause where possible. */
@Override S get();
}复制代码
而后咱们回到以前追到的iteratorFor方法，知道其返回的是 Iterator<ServiceProvider>类型
/** * Returns an iterator to iterate over the implementations of {@code * service} in modules defined to the given class loader or in custom * layers with a module defined to this class loader. */
private Iterator<ServiceProvider> iteratorFor(ClassLoader loader) {
// modules defined to the class loader
ServicesCatalog catalog;
if (loader == null) {
catalog = BootLoader.getServicesCatalog();
} else {
catalog = ServicesCatalog.getServicesCatalogOrNull(loader);
}
List<ServiceProvider> providers;
if (catalog == null) {
providers = List.of();
} else {
providers = catalog.findServices(serviceName);
}
...
}复制代码
而后回到ModuleServicesLookupIterator()这个构造函数，直接看这个内部类,也就是调用这个
/** * Implements lazy service provider lookup of service providers that * are provided by modules defined to a class loader or to modules in * layers with a module defined to the class loader. */
private final class ModuleServicesLookupIterator<T> implements Iterator<Provider<T>> {
ClassLoader currentLoader;
Iterator<ServiceProvider> iterator;
Provider<T> nextProvider;
ServiceConfigurationError nextError;
ModuleServicesLookupIterator() {
this.currentLoader = loader;
this.iterator = iteratorFor(loader);
}
...
}复制代码
在newLookupIterator这个方法中获得ModuleServicesLookupIterator的实例first,并调用其hasNext方法
/** * Returns a new lookup iterator. */
private Iterator<Provider<S>> newLookupIterator() {
assert layer == null || loader == null;
if (layer != null) {
return new LayerLookupIterator<>();
} else {
Iterator<Provider<S>> first = new ModuleServicesLookupIterator<>();
Iterator<Provider<S>> second = new LazyClassPathLookupIterator<>();
return new Iterator<Provider<S>>() {
@Override
public boolean hasNext() {
return (first.hasNext() || second.hasNext());
}
@Override
public Provider<S> next() {
if (first.hasNext()) {
return first.next();
} else if (second.hasNext()) {
return second.next();
} else {
throw new NoSuchElementException();
}
}
};
}复制代码
咱们来进入这个hasNext方法，也就是在这里，调用了loadProvider生成了一个bean
@Override
public boolean hasNext() {
while (nextProvider == null && nextError == null) {
// get next provider to load
while (!iterator.hasNext()) {
if (currentLoader == null) {
return false;
} else {
currentLoader = currentLoader.getParent();
iterator = iteratorFor(currentLoader);
}
}
// attempt to load provider
ServiceProvider provider = iterator.next();
try {
@SuppressWarnings("unchecked")
Provider<T> next = (Provider<T>) loadProvider(provider);
nextProvider = next;
} catch (ServiceConfigurationError e) {
nextError = e;
}
}
return true;
}
@Override
public Provider<T> next() {
if (!hasNext())
throw new NoSuchElementException();
Provider<T> provider = nextProvider;
if (provider != null) {
nextProvider = null;
return provider;
} else {
ServiceConfigurationError e = nextError;
assert e != null;
nextError = null;
throw e;
}
}
}复制代码
走进这个loadProvider方法,抛开前面全部，咱们只看最后返回为:new ProviderImpl<S>(service, type, ctor, acc)
/** * Loads a service provider in a module. * * Returns {@code null} if the service provider's module doesn't read * the module with the service type. * * @throws ServiceConfigurationError if the class cannot be loaded or * isn't the expected sub-type (or doesn't define a provider * factory method that returns the expected type) */
private Provider<S> loadProvider(ServiceProvider provider) {
Module module = provider.module();
if (!module.canRead(service.getModule())) {
// module does not read the module with the service type
return null;
}
String cn = provider.providerName();
Class<?> clazz = null;
if (acc == null) {
try {
clazz = Class.forName(module, cn);
} catch (LinkageError e) {
fail(service, "Unable to load " + cn, e);
}
} else {
PrivilegedExceptionAction<Class<?>> pa = () -> Class.forName(module, cn);
try {
clazz = AccessController.doPrivileged(pa);
} catch (PrivilegedActionException pae) {
Throwable x = pae.getCause();
fail(service, "Unable to load " + cn, x);
return null;
}
}
if (clazz == null) {
fail(service, "Provider " + cn + " not found");
}
int mods = clazz.getModifiers();
if (!Modifier.isPublic(mods)) {
fail(service, clazz + " is not public");
}
// if provider in explicit module then check for static factory method
if (inExplicitModule(clazz)) {
Method factoryMethod = findStaticProviderMethod(clazz);
if (factoryMethod != null) {
Class<?> returnType = factoryMethod.getReturnType();
if (!service.isAssignableFrom(returnType)) {
fail(service, factoryMethod + " return type not a subtype");
}
@SuppressWarnings("unchecked")
Class<? extends S> type = (Class<? extends S>) returnType;
return new ProviderImpl<S>(service, type, factoryMethod, acc);
}
}
// no factory method so must be a subtype
if (!service.isAssignableFrom(clazz)) {
fail(service, clazz.getName() + " not a subtype");
}
@SuppressWarnings("unchecked")
Class<? extends S> type = (Class<? extends S>) clazz;
@SuppressWarnings("unchecked")
Constructor<? extends S> ctor = (Constructor<? extends S> ) getConstructor(clazz);
return new ProviderImpl<S>(service, type, ctor, acc);
}复制代码
最后，咱们经过查看这个ProviderImpl类终于获得了咱们想要获得的结果。
/** * A Provider implementation that supports invoking, with reduced * permissions, the static factory to obtain the provider or the * provider's no-arg constructor. */
private static class ProviderImpl<S> implements Provider<S> {
final Class<S> service;
final Class<? extends S> type;
final Method factoryMethod; // factory method or null
final Constructor<? extends S> ctor; // public no-args constructor or null
final AccessControlContext acc;
ProviderImpl(Class<S> service,
Class<? extends S> type,
Method factoryMethod,
AccessControlContext acc) {
this.service = service;
this.type = type;
this.factoryMethod = factoryMethod;
this.ctor = null;
this.acc = acc;
}
ProviderImpl(Class<S> service,
Class<? extends S> type,
Constructor<? extends S> ctor,
AccessControlContext acc) {
this.service = service;
this.type = type;
this.factoryMethod = null;
this.ctor = ctor;
this.acc = acc;
}
@Override
public Class<? extends S> type() {
return type;
}
@Override
public S get() {
if (factoryMethod != null) {
return invokeFactoryMethod();
} else {
return newInstance();
}
}复制代码
IOC和模块化所提供的相似效果的最大的区别就是，前者是提供了实例化的bean(即使是经过AOP实现的，这点很重要，Java9模块化在使用Spring的时候会有特别的设置)，并且是基于Spring容器的单例的存在(多例注入的问题请参考我这方面的Spring源码解析)，后者是提供了class字节码所在的路径，用的时候内部会自行生成实例，因此是多例的。
其实整个过程，Java的模块化文件系统起了很大的做用(这块看状况假如篇幅比较长久不放在个人书里了)，而后本身追源码的思路也在这里给你们展示了一番，但愿能够对你们有所帮助，看源码不要上来就瞎找的。另外，最重要的一点就是，不要由于源码不少，很复杂就轻言放弃，看的多了，看的久了，天然就有一套属于本身的方法论了。
相关文章
- 1. 聊聊IOC中依赖注入那些事 (Dependency inject)
- 2. 聊一聊PHP的依赖注入(DI) 和 控制反转(IoC)
- 3. 数栈技术分享：聊聊IOC中依赖注入那些事 (Dependency inject)
- 4. 依赖注入 IOC容器的实现
- 5. C++ 简单实现 依赖注入（IOC）
- 6. IOC(控制反转)与DI（依赖注入）理解与区别
- 7. .NET平台依赖注入机制及IoC的设计与实现
- 8. 依赖注入（IOC）
- 9. 聊聊java9的classloader
- 10. 设计模式系列20---聊聊IoC与中介者
- 更多相关文章...
- • Spring DI（依赖注入）的实现方式：属性注入和构造注入 - Spring教程
- • SVG 模糊效果 - SVG 教程
- • Spring Cloud 微服务实战(三) - 服务注册与发现
- • Java Agent入门实战（一）-Instrumentation介绍与使用
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
