基于javaConfig的springDataJpa+dubbo+springMvc搭建(二)

最新推荐文章于 2024-07-05 17:09:59 发布
最新推荐文章于 2024-07-05 17:09:59 发布
阅读量3.4k 收藏
点赞数
分类专栏： java 文章标签： spring dubbo javaConfig
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiejx618/article/details/50439068
版权

前文基本把dubbo框架搭出来了,本文在此框架,重点解决@org.springframework.transaction.annotation.Transactional带出的问题,以加入简单的权限管理功能进来为例.当然要完善这个框架之前,会先把权限的开关关闭.即注释org.exam.web.config.MvcConfig#addInterceptors方法.使用了spring data jpa,解决懒加载,可以离不开Transactional注解.不知算不算bug,到了现在的dubbox也没更改,总之就出了问题.先看看问题:一个服务实现类加了@Transactional,使用注解扫描就不能暴露服务(网上有解决办法,试了,没有效果).
具体出现问题例子:用户与角色是多对多的关系,查询列表时,没必要加载用户的角色,但查询某个用户时,可将用户的角色查询出来.
用户与角色的实体关系:

    @ManyToMany(fetch = FetchType.LAZY, cascade = {CascadeType.PERSIST, CascadeType.MERGE})
    @JoinTable(name = Constants.TABLE_PREFIX + "user_role")
    private Set<Role> roles = new HashSet<Role>();

查询用户分页数据:

    public Page<User> findAll(String id, String username, Pageable pageable) {
        return userRepository.findAll((root, query, cb) -> {
            List<Predicate> criteria = new ArrayList<>();
            if (StringUtils.hasLength(id)) {
                criteria.add(cb.equal(root.get(User_.id), id));
            }
            if (StringUtils.hasLength(username)) {
                criteria.add(cb.like(root.get(User_.username), "%" + username + "%"));
            }
            if (criteria.size() > 0) {
                return cb.and(criteria.toArray(new Predicate[criteria.size()]));
            } else {
                return null;
            }
        }, pageable);
    }

查询某个用户数据:

    @Transactional(readOnly = true)//解决懒加载
    public User findOne(String id) {
        User user = userRepository.findOne(id);
        user.getRoles().forEach(Role::getId);
        return user;
    }

使用扫描方法暴露Dubbo服务的主要逻辑在

com.alibaba.dubbo.config.spring.AnnotationBean
public class AnnotationBean extends AbstractConfig implements DisposableBean, BeanFactoryPostProcessor, BeanPostProcessor, ApplicationContextAware {
    //其它省略
    //主要将带有com.alibaba.dubbo.config.annotation.Service注解的类注册成Bean
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
            throws BeansException {
        if (annotationPackage == null || annotationPackage.length() == 0) {
            return;
        }
        if (beanFactory instanceof BeanDefinitionRegistry) {
            try {
                // init scanner
                Class<?> scannerClass = ReflectUtils.forName("org.springframework.context.annotation.ClassPathBeanDefinitionScanner");
                Object scanner = scannerClass.getConstructor(new Class<?>[] {BeanDefinitionRegistry.class, boolean.class}).newInstance(new Object[] {(BeanDefinitionRegistry) beanFactory, true});
                // add filter
                Class<?> filterClass = ReflectUtils.forName("org.springframework.core.type.filter.AnnotationTypeFilter");
                Object filter = filterClass.getConstructor(Class.class).newInstance(Service.class);
                Method addIncludeFilter = scannerClass.getMethod("addIncludeFilter", ReflectUtils.forName("org.springframework.core.type.filter.TypeFilter"));
                addIncludeFilter.invoke(scanner, filter);
                // scan packages
                String[] packages = Constants.COMMA_SPLIT_PATTERN.split(annotationPackage);
                Method scan = scannerClass.getMethod("scan", new Class<?>[]{String[].class});
                scan.invoke(scanner, new Object[] {packages});
            } catch (Throwable e) {
                // spring 2.0
            }
        }
    }
    //主要将带有com.alibaba.dubbo.config.annotation.Service注解的类的方法暴露成服务.
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        //看以下注释
        if (! isMatchPackage(bean)) {
            return bean;
        }
        //如果经过了代理,这里也获取不到
        Service service = bean.getClass().getAnnotation(Service.class);
        if (service != null) {
            ServiceBean<Object> serviceConfig = new ServiceBean<Object>(service);
            if (void.class.equals(service.interfaceClass())
                    && "".equals(service.interfaceName())) {
                if (bean.getClass().getInterfaces().length > 0) {
                    //经过了代理,这里也不对
                    serviceConfig.setInterface(bean.getClass().getInterfaces()[0]);
                } else {
                    throw new IllegalStateException("Failed to export remote service class " + bean.getClass().getName() + ", cause: The @Service undefined interfaceClass or interfaceName, and the service class unimplemented any interfaces.");
                }
            }
            if (applicationContext != null) {
                serviceConfig.setApplicationContext(applicationContext);
                if (service.registry() != null && service.registry().length > 0) {
                    List<RegistryConfig> registryConfigs = new ArrayList<RegistryConfig>();
                    for (String registryId : service.registry()) {
                        if (registryId != null && registryId.length() > 0) {
                            registryConfigs.add((RegistryConfig)applicationContext.getBean(registryId, RegistryConfig.class));
                        }
                    }
                    serviceConfig.setRegistries(registryConfigs);
                }
                if (service.provider() != null && service.provider().length() > 0) {
                    serviceConfig.setProvider((ProviderConfig)applicationContext.getBean(service.provider(),ProviderConfig.class));
                }
                if (service.monitor() != null && service.monitor().length() > 0) {
                    serviceConfig.setMonitor((MonitorConfig)applicationContext.getBean(service.monitor(), MonitorConfig.class));
                }
                if (service.application() != null && service.application().length() > 0) {
                    serviceConfig.setApplication((ApplicationConfig)applicationContext.getBean(service.application(), ApplicationConfig.class));
                }
                if (service.module() != null && service.module().length() > 0) {
                    serviceConfig.setModule((ModuleConfig)applicationContext.getBean(service.module(), ModuleConfig.class));
                }
                if (service.provider() != null && service.provider().length() > 0) {
                    serviceConfig.setProvider((ProviderConfig)applicationContext.getBean(service.provider(), ProviderConfig.class));
                } else {

                }
                if (service.protocol() != null && service.protocol().length > 0) {
                    List<ProtocolConfig> protocolConfigs = new ArrayList<ProtocolConfig>();
                    for (String protocolId : service.registry()) {
                        if (protocolId != null && protocolId.length() > 0) {
                            protocolConfigs.add((ProtocolConfig)applicationContext.getBean(protocolId, ProtocolConfig.class));
                        }
                    }
                    serviceConfig.setProtocols(protocolConfigs);
                }
                try {
                    serviceConfig.afterPropertiesSet();
                } catch (RuntimeException e) {
                    throw (RuntimeException) e;
                } catch (Exception e) {
                    throw new IllegalStateException(e.getMessage(), e);
                }
            }
            serviceConfig.setRef(bean);
            serviceConfigs.add(serviceConfig);
            serviceConfig.export();
        }
        return bean;
    }

    private boolean isMatchPackage(Object bean) {
        if (annotationPackages == null || annotationPackages.length == 0) {
            return true;
        }
        //如果是JDK代理过的类,这里判断就会有错
        String beanClassName = bean.getClass().getName();
        for (String pkg : annotationPackages) {
            if (beanClassName.startsWith(pkg)) {
                return true;
            }
        }
        return false;
    }
}

因为使用了@Transactional注解,spring就会生成代理实例注册成Bean,所我所知,以上几个地方都不够严谨科学,对于新版本的spring已不能适应.因此将整个类修改如下:
来源:https://raw.githubusercontent.com/dangdangdotcom/dubbox/master/dubbo-config/dubbo-config-spring/src/main/java/com/alibaba/dubbo/config/spring/AnnotationBean.java

/*
 * Copyright 1999-2012 Alibaba Group.
 *  
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *  
 *      http://www.apache.org/licenses/LICENSE-2.0
 *  
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.alibaba.dubbo.config.spring;

import com.alibaba.dubbo.common.Constants;
import com.alibaba.dubbo.common.logger.Logger;
import com.alibaba.dubbo.common.logger.LoggerFactory;
import com.alibaba.dubbo.common.utils.ConcurrentHashSet;
import com.alibaba.dubbo.common.utils.ReflectUtils;
import com.alibaba.dubbo.config.*;
import com.alibaba.dubbo.config.annotation.Reference;
import com.alibaba.dubbo.config.annotation.Service;
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanInitializationException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * AnnotationBean
 *
 * @author william.liangf
 * @export
 */
public class AnnotationBean extends AbstractConfig implements DisposableBean, BeanFactoryPostProcessor, BeanPostProcessor, ApplicationContextAware {

    private static final long serialVersionUID = -7582802454287589552L;

    private static final Logger logger = LoggerFactory.getLogger(Logger.class);

    private String annotationPackage;

    private String[] annotationPackages;

    private final Set<ServiceConfig<?>> serviceConfigs = new ConcurrentHashSet<ServiceConfig<?>>();

    private final ConcurrentMap<String, ReferenceBean<?>> referenceConfigs = new ConcurrentHashMap<String, ReferenceBean<?>>();

    public String getPackage() {
        return annotationPackage;
    }

    public void setPackage(String annotationPackage) {
        this.annotationPackage = annotationPackage;
        this.annotationPackages = (annotationPackage == null || annotationPackage.length() == 0) ? null
                : Constants.COMMA_SPLIT_PATTERN.split(annotationPackage);
    }

    private ApplicationContext applicationContext;

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
            throws BeansException {
        if (annotationPackage == null || annotationPackage.length() == 0) {
            return;
        }
        if (beanFactory instanceof BeanDefinitionRegistry) {
            try {
                // init scanner
                Class<?> scannerClass = ReflectUtils.forName("org.springframework.context.annotation.ClassPathBeanDefinitionScanner");
                Object scanner = scannerClass.getConstructor(new Class<?>[]{BeanDefinitionRegistry.class, boolean.class}).newInstance(new Object[]{(BeanDefinitionRegistry) beanFactory, true});
                // add filter
                Class<?> filterClass = ReflectUtils.forName("org.springframework.core.type.filter.AnnotationTypeFilter");
                Object filter = filterClass.getConstructor(Class.class).newInstance(Service.class);
                Method addIncludeFilter = scannerClass.getMethod("addIncludeFilter", ReflectUtils.forName("org.springframework.core.type.filter.TypeFilter"));
                addIncludeFilter.invoke(scanner, filter);
                // scan packages
                String[] packages = Constants.COMMA_SPLIT_PATTERN.split(annotationPackage);
                Method scan = scannerClass.getMethod("scan", new Class<?>[]{String[].class});
                scan.invoke(scanner, new Object[]{packages});
            } catch (Throwable e) {
                // spring 2.0
            }
        }
    }

    public void destroy() throws Exception {
        for (ServiceConfig<?> serviceConfig : serviceConfigs) {
            try {
                serviceConfig.unexport();
            } catch (Throwable e) {
                logger.error(e.getMessage(), e);
            }
        }
        for (ReferenceConfig<?> referenceConfig : referenceConfigs.values()) {
            try {
                referenceConfig.destroy();
            } catch (Throwable e) {
                logger.error(e.getMessage(), e);
            }
        }
    }

    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        if (!isMatchPackage(bean)) {
            return bean;
        }
        Class<?> clazz = bean.getClass();
        if (isProxyBean(bean)) {
            clazz = AopUtils.getTargetClass(bean);
        }
        Service service = clazz.getAnnotation(Service.class);
        if (service != null) {
            ServiceBean<Object> serviceConfig = new ServiceBean<Object>(service);
            if (void.class.equals(service.interfaceClass())
                    && "".equals(service.interfaceName())) {
                if (clazz.getInterfaces().length > 0) {
                    serviceConfig.setInterface(clazz.getInterfaces()[0]);
                } else {
                    throw new IllegalStateException("Failed to export remote service class " + clazz.getName() + ", cause: The @Service undefined interfaceClass or interfaceName, and the service class unimplemented any interfaces.");
                }
            }
            if (applicationContext != null) {
                serviceConfig.setApplicationContext(applicationContext);
                if (service.registry() != null && service.registry().length > 0) {
                    List<RegistryConfig> registryConfigs = new ArrayList<RegistryConfig>();
                    for (String registryId : service.registry()) {
                        if (registryId != null && registryId.length() > 0) {
                            registryConfigs.add((RegistryConfig) applicationContext.getBean(registryId, RegistryConfig.class));
                        }
                    }
                    serviceConfig.setRegistries(registryConfigs);
                }
                if (service.provider() != null && service.provider().length() > 0) {
                    serviceConfig.setProvider((ProviderConfig) applicationContext.getBean(service.provider(), ProviderConfig.class));
                }
                if (service.monitor() != null && service.monitor().length() > 0) {
                    serviceConfig.setMonitor((MonitorConfig) applicationContext.getBean(service.monitor(), MonitorConfig.class));
                }
                if (service.application() != null && service.application().length() > 0) {
                    serviceConfig.setApplication((ApplicationConfig) applicationContext.getBean(service.application(), ApplicationConfig.class));
                }
                if (service.module() != null && service.module().length() > 0) {
                    serviceConfig.setModule((ModuleConfig) applicationContext.getBean(service.module(), ModuleConfig.class));
                }
                if (service.provider() != null && service.provider().length() > 0) {
                    serviceConfig.setProvider((ProviderConfig) applicationContext.getBean(service.provider(), ProviderConfig.class));
                } else {

                }
                if (service.protocol() != null && service.protocol().length > 0) {
                    List<ProtocolConfig> protocolConfigs = new ArrayList<ProtocolConfig>();
                    // modified by lishen; fix dubbo's bug
                    for (String protocolId : service.protocol()) {
                        if (protocolId != null && protocolId.length() > 0) {
                            protocolConfigs.add((ProtocolConfig) applicationContext.getBean(protocolId, ProtocolConfig.class));
                        }
                    }
                    serviceConfig.setProtocols(protocolConfigs);
                }
                try {
                    serviceConfig.afterPropertiesSet();
                } catch (RuntimeException e) {
                    throw (RuntimeException) e;
                } catch (Exception e) {
                    throw new IllegalStateException(e.getMessage(), e);
                }
            }
            serviceConfig.setRef(bean);
            serviceConfigs.add(serviceConfig);
            serviceConfig.export();
        }
        return bean;
    }

    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        if (!isMatchPackage(bean)) {
            return bean;
        }
        Class<?> clazz = bean.getClass();
        if (isProxyBean(bean)) {
            clazz = AopUtils.getTargetClass(bean);
        }
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            String name = method.getName();
            if (name.length() > 3 && name.startsWith("set")
                    && method.getParameterTypes().length == 1
                    && Modifier.isPublic(method.getModifiers())
                    && !Modifier.isStatic(method.getModifiers())) {
                try {
                    Reference reference = method.getAnnotation(Reference.class);
                    if (reference != null) {
                        Object value = refer(reference, method.getParameterTypes()[0]);
                        if (value != null) {
                            method.invoke(bean, new Object[]{value});
                        }
                    }
                } catch (Exception e) {
                    // modified by lishen
                    throw new BeanInitializationException("Failed to init remote service reference at method " + name + " in class " + bean.getClass().getName(), e);
//                    logger.error("Failed to init remote service reference at method " + name + " in class " + bean.getClass().getName() + ", cause: " + e.getMessage(), e);
                }
            }
        }
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            try {
                if (!field.isAccessible()) {
                    field.setAccessible(true);
                }
                Reference reference = field.getAnnotation(Reference.class);
                if (reference != null) {
                    Object value = refer(reference, field.getType());
                    if (value != null) {
                        field.set(bean, value);
                    }
                }
            } catch (Exception e) {
                // modified by lishen
                throw new BeanInitializationException("Failed to init remote service reference at filed " + field.getName() + " in class " + bean.getClass().getName(), e);
//              logger.error("Failed to init remote service reference at filed " + field.getName() + " in class " + bean.getClass().getName() + ", cause: " + e.getMessage(), e);
            }
        }
        return bean;
    }

    private Object refer(Reference reference, Class<?> referenceClass) { //method.getParameterTypes()[0]
        String interfaceName;
        if (!"".equals(reference.interfaceName())) {
            interfaceName = reference.interfaceName();
        } else if (!void.class.equals(reference.interfaceClass())) {
            interfaceName = reference.interfaceClass().getName();
        } else if (referenceClass.isInterface()) {
            interfaceName = referenceClass.getName();
        } else {
            throw new IllegalStateException("The @Reference undefined interfaceClass or interfaceName, and the property type " + referenceClass.getName() + " is not a interface.");
        }
        String key = reference.group() + "/" + interfaceName + ":" + reference.version();
        ReferenceBean<?> referenceConfig = referenceConfigs.get(key);
        if (referenceConfig == null) {
            referenceConfig = new ReferenceBean<Object>(reference);
            if (void.class.equals(reference.interfaceClass())
                    && "".equals(reference.interfaceName())
                    && referenceClass.isInterface()) {
                referenceConfig.setInterface(referenceClass);
            }
            if (applicationContext != null) {
                referenceConfig.setApplicationContext(applicationContext);
                if (reference.registry() != null && reference.registry().length > 0) {
                    List<RegistryConfig> registryConfigs = new ArrayList<RegistryConfig>();
                    for (String registryId : reference.registry()) {
                        if (registryId != null && registryId.length() > 0) {
                            registryConfigs.add((RegistryConfig) applicationContext.getBean(registryId, RegistryConfig.class));
                        }
                    }
                    referenceConfig.setRegistries(registryConfigs);
                }
                if (reference.consumer() != null && reference.consumer().length() > 0) {
                    referenceConfig.setConsumer((ConsumerConfig) applicationContext.getBean(reference.consumer(), ConsumerConfig.class));
                }
                if (reference.monitor() != null && reference.monitor().length() > 0) {
                    referenceConfig.setMonitor((MonitorConfig) applicationContext.getBean(reference.monitor(), MonitorConfig.class));
                }
                if (reference.application() != null && reference.application().length() > 0) {
                    referenceConfig.setApplication((ApplicationConfig) applicationContext.getBean(reference.application(), ApplicationConfig.class));
                }
                if (reference.module() != null && reference.module().length() > 0) {
                    referenceConfig.setModule((ModuleConfig) applicationContext.getBean(reference.module(), ModuleConfig.class));
                }
                if (reference.consumer() != null && reference.consumer().length() > 0) {
                    referenceConfig.setConsumer((ConsumerConfig) applicationContext.getBean(reference.consumer(), ConsumerConfig.class));
                }
                try {
                    referenceConfig.afterPropertiesSet();
                } catch (RuntimeException e) {
                    throw (RuntimeException) e;
                } catch (Exception e) {
                    throw new IllegalStateException(e.getMessage(), e);
                }
            }
            referenceConfigs.putIfAbsent(key, referenceConfig);
            referenceConfig = referenceConfigs.get(key);
        }
        return referenceConfig.get();
    }

    private boolean isMatchPackage(Object bean) {
        if (annotationPackages == null || annotationPackages.length == 0) {
            return true;
        }
        Class clazz = bean.getClass();
        if (isProxyBean(bean)) {
            clazz = AopUtils.getTargetClass(bean);
        }
        String beanClassName = clazz.getName();
        for (String pkg : annotationPackages) {
            if (beanClassName.startsWith(pkg)) {
                return true;
            }
        }
        return false;
    }

    private boolean isProxyBean(Object bean) {
        return AopUtils.isAopProxy(bean);
    }

}

本文源码:http://download.csdn.net/detail/xiejx618/9384819

xiejx618
关注
专栏目录
这才是真正的Spring全家桶：Spring+SpringData+MVC+Boot+Cloud
band_mmbx的博客
09-06 256
自我介绍本人三年开发，985硕士，211本科，专业都是软件工程，一直投的是Java后台开发，只投过一次网易的测试，技术不是太牛，但是比较努力。实验室没有项目，so项目经验是0，在去年这个时候看到实验室师兄找工作的艰难，因此开始复习的时间比较早。复习经历写在文末关于复习最后悔的是leetcode没有刷，有时间一定要刷，有时间一定要刷，有时间一定要刷，对解题思路很有帮助。
SpringBoot+SpringCloud面试题整理附答案
q66562636的博客
07-06 1572
什么是SpringBoot？ 1、用来简化spring初始搭建和开发过程使用特定的方式进行配置(properties或者yml文件) 2、创建独立的spring引用程序main方法运行 3、嵌入Tomcat无需部署war包，直接打成jar包nohup java -jar – & 启动就好 4、简化了maven的配置 4、自动配置spring添加对应的starter自动化配置 SpringBoot常用的starter： 1、spring-boot-starter-web(嵌入Tomcat和web开发需要的se
springmvc+spirng-data-jpa+dubbo项目
05-12
完整的springmvc+jpa+dubbo项目。demo项目里暂时屏蔽了jpa的数据库配置部分，读者可以自行开启或者使用其他orm框架。主要作为dubbo服务开发的演示。
Spring之JavaConfig
努力，学习！
09-23 822
Spring JavaConfig实例 从Spring 3起，JavaConfig功能已经包含在Spring核心模块，它允许开发者将bean定义和在Spring配置XML文件到Java类中。但是，仍然允许使用经典的XML方式来定义bean和配置，JavaConfig是另一种替代解决方案。 我们写一个简单的实例看看，实现输出 hello world 接口 package com.pepper.it...
初学Spring之 JavaConfig 实现配置
最新发布
m0_58838332的博客
07-05 366
会被 Spring 容器托管，注册到容器中，因为他本来就是一个 @Component。表示这个类被 Spring 接管了，注册到了容器中。扫描：@ComponentScans("xx")导入其他类：@Import(xx.class)@Configuration 代表这是一个。注册一个 bean，相当于 bean 标签。使用 Java 方式配置 Spring。通过配置类的 class 对象加载。和 beans.xml 一样。相当于 bean 标签中的。相当于 bean 标签中的。
【8】使用Java的方式配置Spring
Kuber
11-29 148
9、使用Java的方式配置Spring 我们现在要完全不使用Spring的xml配置了，全权交给Java来做！ JavaConfig是Spring的一个子项目，在Spring4之后，它成为了一个核心功能 pojo包 /*这里这个注解的意思，就是说明这个类被Spring接管了，注册到了容器中*/ @Component public class User { private String name; public String getName() { return name;
Spring JavaConfig
Spirit_NKlaus的专栏
11-08 289
定义接口 public interface HelloWorld { void printMsg(String msg); } 接口实现类 public class HelloWorldImpl implements HelloWorld { @Override public void printMsg(String msg) { System...
基于javaConfig的springDataJpa+dubbo+springMvc搭建
12-29
在提供的文件列表中，"基于javaConfig的springDataJpa+dubbo+springMvc搭建.txt"可能包含详细的搭建步骤和示例代码，"pom.xml"是项目的依赖管理文件，"sdk"和"web"、"app"可能是项目代码或资源文件的目录。...
基于javaConfig的springDataJpa+dubbo+springMvc的搭建
12-30
在本项目中，我们主要探讨如何使用JavaConfig配置Spring Data JPA、Dubbo以及Spring MVC来构建一个完整的微服务架构。下面将详细讲解这些技术及其整合过程。 **Spring Data JPA** Spring Data JPA是Spring框架的一...
Spring中的JavaConfig
温良
09-12 681
什么是JavaConfig、通过注解和配置类完成Spring的相关配置 Spring配置都做了什么？ 注册组件、其他配置(扫描包配置、properties配置文件加载、aspectj注解开关、事务注解开关) 目的：干掉配置文件 application.xml 目录 配置类 注册组件 扫描包配置 事务注解驱动 单元测试加载配置类 properties配置文件加载（了解） aspectj注解开关 配置类 替代的application.xml 要在配置类中注册组件 其他配置 @C..
Spring的JavaConfig
qq_16268979的博客
11-08 380
spring曾经很多东西也是被诟病的，当然这也是说明有很多进步的空间，其中xml的配置是诟病最多的，后面spring就推出了JavaConfig来进行配置优化。这篇文章就由简入繁进行介绍。 一、@Configuration <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001
spring的javaConfig
yfyh2021的博客
09-04 125
1.基于java容器的配置 @Configuration 就相当于创建了一个xml 文件 @ComponentScan("com.yang") 就相当于component-scan <context:component-scan base-package="com.yang" > @PropertySource("classpath:db.properties") 就是引入外部文件 2.将一个类引入到ioc容器中 2.1@Bean 比如 @Configurati.
【归纳总结】Spring之JavaConfig
Octavius_的博客
04-01 197
简单来说，就是不再使用xml配置文件来配置，改为使用配置类来进行配置 配置类 @Configuration 把一个类标记为配置类，把配置也作为容器中的组件（可以使用注入功能的注解） @ComponentScan 扫描的范围 @EnableTransactionManagement 对应标签：<tx:annotation-driven transaction-manager="transactionManager"/> @EnableAspectJAutoProxy 对应标签：<aop:as
Spring — 4. javaConfig配置类
小小小猿
08-29 282
配置类Configuration：注意：使用ApplicationContext的实现类来获取IOC容器中的配置类所装配的Bean。
java spring config_spring java config 初探
weixin_42305622的博客
02-24 146
Java Config 注解spring java config作为同xml配置形式的另一种表达形式，使用的场景越来越多，在新版本的spring boot中大量使用，今天我们来看下用到的主要注解有哪些。Configuration: 继承Component注解，默认解析为spring的顶级BeanFactory。作用于类上面，等价于applicationContext.xml文件Bean ：作用在...
【Spring第七篇】Java配置类：JavaConfig
...
04-10 6532
Java配置类：JavaConfig 在spring配置中 applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.
spring全家桶之spring——5、JavaConfig
zengwei的博客
04-13 603
JavaConfig这个东西呢，能够让你省去配置beans.xml这个文件，可以通过注解的方式来实现，比xml的形式要方便些，而且实际开发主要用的也是注解，xml太麻烦了，看着就烦，又不是写安卓，搞这么多xml干嘛，去他大爷的 首先有一个这个类 public class Test_6_1 { public void hello(){ System.out.println...
Spring篇—使用JavaConfig实现配置，一篇文章让你精通关于Spring新的配置Bean方式！
我热爱学习，也乐于分享。无论是科技前沿的洞见，还是生活中的小技巧，我都会在这里与你分享。我相信，知识就是力量，而分享则能让这份力量得到更好的传递。
11-25 362
至此，你就掌握了关于Java中如何通过配置类来进行常见类的注入，通过配置类，你就可以将已有些工作中使用到的某些类注入到Spring容器中，直接在需要使用的业务类中通过@Autowired注解将这个类注入进来就能使用类中的方法了！预祝各位早日成为Java全栈工程师，后续还会持续更新关于Spring的相关技术栈介绍，敬请期待！关于配置Bean的方式，大家尤其关注代码中的注释内容，详细的介绍都在注释中。这种纯Java的配置文件，在SpringBoot中随处可见。2、编写config.java文件。
使用springboot+springmvc+dubbo+mybatis搭建微服务
04-12
架构有哪些好处？ 使用 SpringBoot、SpringMVC、Dubbo、MyBatis 搭建微服务架构可以带来很多好处，比如： 1. 可以根据需求快速构建出自己的微服务架构，提高开发效率和项目交付速度。 2. 每个微服务可以独立开发、测试、部署、升级和维护，具有良好的隔离性和可扩展性。 3. 微服务之间可以通过 Dubbo 进行远程调用，实现服务间的解耦和高效通信。 4. MyBatis 可以提供优秀的 ORM 映射支持，简化数据库操作，进一步提高开发效率。 总之，采用 SpringBoot、SpringMVC、Dubbo、MyBatis 搭建微服务架构可以让我们更加专注业务逻辑，提高开发效率和系统可维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值