Общее представление об использовании фреймворка и сравнение производительности копирования бинов

Копия атрибута компонента, в основном для введения нескольких часто используемых схем использования инфраструктуры копирования и соответствующего сравнения производительности.

Выбранная рамка

• cglib (BeanCoier, упакованный Spring, и родной BeanCopier)
• apache
• MapStruct
• Spring
• HuTool

оригинал:Положение использования среды копирования Common Bean и сравнение производительности

I. Предыстория

Когда объем бизнеса невелик, нет проблем с тем, какой фреймворк вы выберете, если функция его поддерживает; но когда объем данных велик, вам может потребоваться рассмотреть проблемы с производительностью; не только медленный, но и найденный что будет конкуренция замков, которая есть Nip

В проекте используется Spring BeanUtils, версия3.2.4.RELEASE, версия относительно старая, основная проблема в том, чтоorg.springframework.beans.CachedIntrospectionResults.forClass

/**
 * Create CachedIntrospectionResults for the given bean class.
 * <P>We don't want to use synchronization here. Object references are atomic,
 * so we can live with doing the occasional unnecessary lookup at startup only.
 * @param beanClass the bean class to analyze
 * @return the corresponding CachedIntrospectionResults
 * @throws BeansException in case of introspection failure
 */
static CachedIntrospectionResults forClass(Class beanClass) throws BeansException {
    CachedIntrospectionResults results;
    Object value;
    synchronized (classCache) {
        value = classCache.get(beanClass);
    }
    if (value instanceof Reference) {
        Reference ref = (Reference) value;
        results = (CachedIntrospectionResults) ref.get();
    }
    else {
        results = (CachedIntrospectionResults) value;
    }
    if (results == null) {
        if (ClassUtils.isCacheSafe(beanClass, CachedIntrospectionResults.class.getClassLoader()) ||
                isClassLoaderAccepted(beanClass.getClassLoader())) {
            results = new CachedIntrospectionResults(beanClass);
            synchronized (classCache) {
                classCache.put(beanClass, results);
            }
        }
        else {
            if (logger.isDebugEnabled()) {
                logger.debug("Not strongly caching class [" + beanClass.getName() + "] because it is not cache-safe");
            }
            results = new CachedIntrospectionResults(beanClass);
            synchronized (classCache) {
                classCache.put(beanClass, new WeakReference<CachedIntrospectionResults>(results));
            }
        }
    }
    return results;
}

Глядя на вышеуказанную реализацию, замок синхронизации добавляют каждый раз, когда значение приобретается, и замок глобальный.classCache, это уж слишком, тонкость в том, что этот комментарий к коду, после Google Translate,

Мы не хотим использовать здесь синхронизацию. Ссылки на объекты являются атомарными, поэтому при запуске мы можем выполнять только случайные ненужные поиски.

Это означает, что я использую его при запуске, и я не использую его часто, поэтому использование синхронного блока кода не является большой проблемой...

Но когдаBeanUtils#copyPropertiesБольно в середине, я буду выполнять этот метод каждый раз, это больно

---

Конечно, мы обычно используем Spring5 + теперь, и этот код уже был преобразован. Новая версия выглядит следующим образом, и вышеупомянутая проблема параллелизма больше не существует.

/**
 * Create CachedIntrospectionResults for the given bean class.
 * @param beanClass the bean class to analyze
 * @return the corresponding CachedIntrospectionResults
 * @throws BeansException in case of introspection failure
 */
@SuppressWarnings("unchecked")
static CachedIntrospectionResults forClass(Class<?> beanClass) throws BeansException {
    CachedIntrospectionResults results = strongClassCache.get(beanClass);
    if (results != null) {
        return results;
    }
    results = softClassCache.get(beanClass);
    if (results != null) {
        return results;
    }

    results = new CachedIntrospectionResults(beanClass);
    ConcurrentMap<Class<?>, CachedIntrospectionResults> classCacheToUse;

    if (ClassUtils.isCacheSafe(beanClass, CachedIntrospectionResults.class.getClassLoader()) ||
            isClassLoaderAccepted(beanClass.getClassLoader())) {
        classCacheToUse = strongClassCache;
    }
    else {
        if (logger.isDebugEnabled()) {
            logger.debug("Not strongly caching class [" + beanClass.getName() + "] because it is not cache-safe");
        }
        classCacheToUse = softClassCache;
    }

    CachedIntrospectionResults existing = classCacheToUse.putIfAbsent(beanClass, results);
    return (existing != null ? existing : results);
}

II. Другой кадр с помощью жеста

Далее давайте взглянем на варианты использования нескольких распространенных фреймворков копирования компонентов, а также на сравнительные тесты.

1. apache BeanUtils

Спецификация Али, четко указано, не используйте ее, идея после установки спецификаций кода плагина Али, будет подсказка

Использование позы относительно простое, а введение зависимостей

<!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
<dependency>
    <groupId>commons-beanutils</groupId>
    <artifactId>commons-beanutils</artifactId>
    <version>1.9.4</version>
</dependency>

копия свойства

@Component
public class ApacheCopier {
    public <K, T> T copy(K source, Class<T> target) throws IllegalAccessException, InstantiationException, InvocationTargetException {
        T res = target.newInstance();
        // 注意，第一个参数为target，第二个参数为source
        // 与其他的正好相反 
        BeanUtils.copyProperties(res, source);
        return res;
    }
}

2. cglib BeanCopier

cglib реализует копирование атрибутов через динамический прокси, что существенно отличается от описанной выше реализации на основе отражения, что также является основной причиной его лучшей производительности.

В среде Spring, как правило, не требуется дополнительных зависимостей или непосредственного введенияspring-core

<!--      cglib  -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.2.8.RELEASE</version>
    <scope>compile</scope>
</dependency>

копия свойства

@Component
public class SpringCglibCopier {
    /**
     * cglib 对象转换
     *
     * @param source
     * @param target
     * @param <K>
     * @param <T>
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public <K, T> T copy(K source, Class<T> target) throws IllegalAccessException, InstantiationException {
        BeanCopier copier = BeanCopier.create(source.getClass(), target, false);
        T res = target.newInstance();
        copier.copy(source, res, null);
        return res;
    }
}

Конечно, вы также можете напрямую использовать чистую версию cglib для введения зависимостей.

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

Используйте ту же позу, что и выше

@Component
public class PureCglibCopier {
    /**
     * cglib 对象转换
     *
     * @param source
     * @param target
     * @param <K>
     * @param <T>
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public <K, T> T copy(K source, Class<T> target) throws IllegalAccessException, InstantiationException {
        BeanCopier copier = BeanCopier.create(source.getClass(), target, false);
        T res = target.newInstance();
        copier.copy(source, res, null);
        return res;
    }
}

3. spring BeanUtils

Вот использование весны5.2.1.RELEASE, Не используйте 3.2, иначе производительность при параллелизме будет действительно трогательной.

На основе самоанализа + размышления, с помощью методов получения/установки для достижения копирования атрибутов, производительность выше, чем у apache.

Основные зависимости

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>5.2.1.RELEASE</version>
    <scope>compile</scope>
</dependency>

копия свойства

@Component
public class SpringBeanCopier {

    /**
     * 对象转换
     *
     * @param source
     * @param target
     * @param <K>
     * @param <T>
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public <K, T> T copy(K source, Class<T> target) throws IllegalAccessException, InstantiationException {
        T res = target.newInstance();
        BeanUtils.copyProperties(source, res);
        return res;
    }
}

4. hutool BeanUtil

hutool предоставляет множество классов java-инструментов, судя по тестовому эффекту, его производительность будет выше, чем у apache, но ниже, чем у spring.

импортировать зависимости

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-core</artifactId>
    <version>5.6.0</version>
</dependency>

использовать позу

@Component
public class HutoolCopier {

    /**
     * bean 对象转换
     *
     * @param source
     * @param target
     * @param <K>
     * @param <T>
     * @return
     */
    public <K, T> T copy(K source, Class<T> target) throws Exception {
        return BeanUtil.toBean(source, target);
    }
}

5. MapStruct

Производительность MapStruct мощнее, а недостатки более очевидны.Необходимо объявить интерфейс преобразования бина и реализовать копирование автоматической генерацией кода.Производительность сравнима с прямым получением/установкой.

импортировать зависимости

<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct</artifactId>
    <version>1.4.2.Final</version>
</dependency>
<dependency>
    <groupId>org.mapstruct</groupId>
    <artifactId>mapstruct-processor</artifactId>
    <version>1.4.2.Final</version>
</dependency>

использовать позу

@Mapper
public interface MapStructCopier {
    Target copy(Source source);
}

@Component
public class MapsCopier {
    private MapStructCopier mapStructCopier = Mappers.getMapper(MapStructCopier.class);

    public Target copy(Source source, Class<Target> target) {
        return mapStructCopier.copy(source);
    }
}

Недостатки тоже более очевидны, объявление о преобразовании интерфейса, которое нужно отображать

6. Тест

Определите два bean-компонента для тестирования преобразования, имена атрибутов-членов двух bean-компонентов и типы точно такие же.

@Data
public class Source {
    private Integer id;
    private String user_name;
    private Double price;
    private List<Long> ids;
    private BigDecimal marketPrice;
}

@Data
public class Target {
    private Integer id;
    private String user_name;
    private Double price;
    private List<Long> ids;
    private BigDecimal marketPrice;
}

6.1 Функциональный тест

private Random random = new Random();

public Source genSource() {
    Source source = new Source();
    source.setId(random.nextInt());
    source.setIds(Arrays.asList(random.nextLong(), random.nextLong(), random.nextLong()));
    source.setMarketPrice(new BigDecimal(random.nextFloat()));
    source.setPrice(random.nextInt(120) / 10.0d);
    source.setUser_name("一灰灰Blog");
    return source;
}


 private void copyTest() throws Exception {
        Source s = genSource();
        Target ta = apacheCopier.copy(s, Target.class);
        Target ts = springBeanCopier.copy(s, Target.class);
        Target tc = springCglibCopier.copy(s, Target.class);
        Target tp = pureCglibCopier.copy(s, Target.class);
        Target th = hutoolCopier.copy(s, Target.class);
        Target tm = mapsCopier.copy(s, Target.class);
        System.out.println("source:\t" + s + "\napache:\t" + ta + "\nspring:\t" + ts
                + "\nsCglib:\t" + tc + "\npCglib:\t" + tp + "\nhuTool:\t" + th + "\nmapStruct:\t" + tm);
}

Результат выглядит следующим образом, что соответствует ожиданиям

source:	Source(id=1337715455, user_name=一灰灰Blog, price=7.1, ids=[7283949433132389385, 3441022909341384204, 8273318310870260875], marketPrice=0.04279220104217529296875)
apache:	Target(id=1337715455, user_name=一灰灰Blog, price=7.1, ids=[7283949433132389385, 3441022909341384204, 8273318310870260875], marketPrice=0.04279220104217529296875)
spring:	Target(id=1337715455, user_name=一灰灰Blog, price=7.1, ids=[7283949433132389385, 3441022909341384204, 8273318310870260875], marketPrice=0.04279220104217529296875)
sCglib:	Target(id=1337715455, user_name=一灰灰Blog, price=7.1, ids=[7283949433132389385, 3441022909341384204, 8273318310870260875], marketPrice=0.04279220104217529296875)
pCglib:	Target(id=1337715455, user_name=一灰灰Blog, price=7.1, ids=[7283949433132389385, 3441022909341384204, 8273318310870260875], marketPrice=0.04279220104217529296875)
huTool:	Target(id=1337715455, user_name=一灰灰Blog, price=7.1, ids=[7283949433132389385, 3441022909341384204, 8273318310870260875], marketPrice=0.04279220104217529296875)
mapStruct:	Target(id=1337715455, user_name=一灰灰Blog, price=7.1, ids=[7283949433132389385, 3441022909341384204, 8273318310870260875], marketPrice=0.04279220104217529296875)

6.2 Тест производительности

Далее давайте рассмотрим различные наборы инструментов и посмотрим, как сравнивается производительность копирования атрибутов.

public void test() throws Exception {
    // 第一次用于预热
    autoCheck(Target2.class, 10000);
    autoCheck(Target2.class, 10000);
    autoCheck(Target2.class, 10000_0);
    autoCheck(Target2.class, 50000_0);
    autoCheck(Target2.class, 10000_00);
}

private <T> void autoCheck(Class<T> target, int size) throws Exception {
    StopWatch stopWatch = new StopWatch();
    runCopier(stopWatch, "apacheCopier", size, (s) -> apacheCopier.copy(s, target));
    runCopier(stopWatch, "springCglibCopier", size, (s) -> springCglibCopier.copy(s, target));
    runCopier(stopWatch, "pureCglibCopier", size, (s) -> pureCglibCopier.copy(s, target));
    runCopier(stopWatch, "hutoolCopier", size, (s) -> hutoolCopier.copy(s, target));
    runCopier(stopWatch, "springBeanCopier", size, (s) -> springBeanCopier.copy(s, target));
    runCopier(stopWatch, "mapStruct", size, (s) -> mapsCopier.copy(s, target));
    System.out.println((size / 10000) + "w -------- cost: " + stopWatch.prettyPrint());
}

private <T> void runCopier(StopWatch stopWatch, String key, int size, CopierFunc func) throws Exception {
    stopWatch.start(key);
    for (int i = 0; i < size; i++) {
        Source s = genSource();
        func.apply(s);
    }
    stopWatch.stop();
}

@FunctionalInterface
public interface CopierFunc<T> {
    T apply(Source s) throws Exception;
}

Вывод выглядит следующим образом

1w -------- cost: StopWatch '': running time = 583135900 ns
---------------------------------------------
ns         %     Task name
---------------------------------------------
488136600  084%  apacheCopier
009363500  002%  springCglibCopier
009385500  002%  pureCglibCopier
053982900  009%  hutoolCopier
016976500  003%  springBeanCopier
005290900  001%  mapStruct

10w -------- cost: StopWatch '': running time = 5607831900 ns
---------------------------------------------
ns         %     Task name
---------------------------------------------
4646282100  083%  apacheCopier
096047200  002%  springCglibCopier
093815600  002%  pureCglibCopier
548897800  010%  hutoolCopier
169937400  003%  springBeanCopier
052851800  001%  mapStruct

50w -------- cost: StopWatch '': running time = 27946743000 ns
---------------------------------------------
ns         %     Task name
---------------------------------------------
23115325200  083%  apacheCopier
481878600  002%  springCglibCopier
475181600  002%  pureCglibCopier
2750257900  010%  hutoolCopier
855448400  003%  springBeanCopier
268651300  001%  mapStruct

100w -------- cost: StopWatch '': running time = 57141483600 ns
---------------------------------------------
ns         %     Task name
---------------------------------------------
46865332600  082%  apacheCopier
1019163600  002%  springCglibCopier
1033701100  002%  pureCglibCopier
5897726100  010%  hutoolCopier
1706155900  003%  springBeanCopier
619404300  001%  mapStruct

-	1w	10w	50w	100w
apache	0.488136600s / 084%	4.646282100s / 083%	23.115325200s / 083%	46.865332600s / 083%
spring cglib	0.009363500s / 002%	0.096047200s / 002%	0.481878600s / 002%	1.019163600s / 002%
pure cglibg	0.009385500s / 002%	0.093815600s / 002%	0.475181600s / 002%	1.033701100s / 002%
hutool	0.053982900s / 009%	0.548897800s / 010%	2.750257900s / 010%	5.897726100s / 010%
spring	0.016976500s / 003%	0.169937400s / 003%	0.855448400s / 003%	1.706155900s / 003%
mapstruct	0.005290900s / 001%	0.052851800s / 001%	0.268651300s / 001%	0.619404300s / 001%
total	0.583135900s	5.607831900s	27.946743000s	57.141483600s

В приведенном выше тесте существует другая переменная, то есть тот же источник источника используется для проверки различного преобразования инструмента, но эта разница не влияет на сравнение производительности различных структур, в основном из вышеуказанных результатов работы.

• mapstruct, cglib, spring работают лучше всего
• апач хуже всех работает

Основной тренд эквивалентен:

apache -> 10 * hutool -> 28 * spring -> 45 * cglib -> 83 * mapstruct

Если нам нужно реализовать простую копию bean-компонента, выбор cglib или spring — хороший выбор.

III. Другое

1. Серый блог:liuyueyi.github.io/hexblog

Серый личный блог, записывающий все посты блога по учебе и работе, приглашаю всех в гости

• Исходный код проекта:GitHub.com/JuneB/tickets…

2. Заявление

Это не так хорошо, как письмо. Вышеупомянутое содержание чисто из семьи. Из-за ограниченных личных способностей неизбежно будут упущения и ошибки. Если вы обнаружите ошибки или у вас есть лучшие предложения, вы можете критиковать и поправьте их.

• QQ: серо-серый / 3302797840
• Публичный аккаунт WeChat:серый блог