SpringMVC 源代码深度解析<context:component-scan>（扫描和注册的注解Bean）

最新推荐文章于 2021-12-24 15:22:10 发布
最新推荐文章于 2021-12-24 15:22:10 发布
阅读量9.9k 收藏 16
点赞数 4
CC 4.0 BY-SA版权
分类专栏： SpringMVC 文章标签： springmvc 标签 spring 源代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/congcong68/article/details/40829037
本文详细介绍了SpringMVC中如何通过XML配置文件扫描指定包下的类，并将带有特定注解（如@Controller、@Service）的类注册为Bean的过程。
    

    我们在SpringMVC开发项目中，有的用注解和XML配置Bean,这两种都各有自己的优势，数据源配置比较经常用XML配置，控制层依赖的service比较经常用注解等（在部署时比较不会改变的），我们经常比较常用的注解有@Component是通用标注，@Controller标注web控制器，@Service标注Servicec层的服务，@Respository标注DAO层的数据访问。SpringMVC启动时怎么被自动扫描然后解析并注册到Bean工厂中去（放到DefaultListableBeanFactory中的Map<String, BeanDefinition> beanDefinitionMap中 以BeanName为key）？我们今天带着这些问题来了解分析这实现的过程，我们在分析之前先了解一下这些注解。

   @Controller标注web控制器，@Service标注Service层的服务，@Respository标注DAO层的数据访问。@Component是通用标注，只是定义为一个类为Bean，SpringMVC会把所有添加@Component注解的类作为使用自动扫描注入配置路径下的备选对象。@Controller、@Service\@Respository只是更加的细化，都是被@Component标注，所以我们比较不推荐使用@Component。源代码如下：

  

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Service {
	String value() default "";
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {
	String value() default "";
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Repository {
	String value() default "";
}

  都是有标示@Component

  我们在配置文件中，标示配置需要扫描哪些包下，也可以配置对某个包下不扫描，代码如下：

<context:component-scan base-package="cn.test">
		<context:exclude-filter type="regex" expression="cn.test.*.*.controller"/>
		<context:exclude-filter type="regex" expression="cn.test.*.*.controller2"/>
</context:component-scan>

说明：

   <context:exclude-filter>指定的不扫描包，<context:exclude-filter>指定的扫描包

SpringMVC先读取配置文件，然后根据context:component-scan中属性base-package去扫描指定包下的class和jar文件，把标示@Controller标注web控制器，@Service标注Servicec层的服务，@Respository标注DAO层的数据访问等注解的都获取，并注册为Bean类放到Bean工厂，我们接下来要分析的这个过程。我们平时项目开发都是这样的注解，实现MVC模式，代码如下：

例如：
//控制层
@Controller
@RequestMapping(value="/test")
public class TestController2 {
	@Autowired
	private TestService testService;
	@RequestMapping(value="/index")
	public String getIndex(Model model){
		
		return "";
	}
}

//服务层
@Service("testService")
public class TestServiceImpl implements  TestService{
}

  我们今天的入口点就在这，因为解析注解的到注册，也是先读取配置文件并解析，在解析时扫描对应包下的JAVA类，里面有DefaultBeanDefinitionDocumentReader这个类，doRegisterBeanDefinitions这个方法实现解析配置文件的Bean，这边已经读取进来形成Document 形式存储，然后开始解析Bean,是由BeanDefinitionParserDelegate类实现的，BeanDefinitionParserDelegate完成具体Bean的解析（例如：bean标签、import标签等）这个在上一篇SpringMVC 源代码深度解析 IOC容器（Bean 解析、注册）里有解析，今天注解属于扩展的标签，是由NamespaceHandler和BeanDefinitionParser来解析。源代码如下：

  
public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
		String namespaceUri = getNamespaceURI(ele);
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

  NamespaceHandler这边这边起到了什么作用，根据不同的Namespace获取不同的NamespaceHandler，因为我们在Beans标签配置了命名空间，然后就可以配置对应的标签，解析标签时，比较有自己的所实现的NamespaceHandler来解析，如图所示：



 

   NamespaceHandler中的parse方法是它的子类类NamespaceHandlerSupport实现的，获取通过findParserForElement方法获取BeanDefinitionParser 对象，这个对象在工程初始化时就直接实例化放在缓存中Map<String, BeanDefinitionParser>，然后通过localName获取，源代码如下：

 public BeanDefinition parse(Element element, ParserContext parserContext) {
		return findParserForElement(element, parserContext).parse(element, parserContext);
	}
	private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
		String localName = parserContext.getDelegate().getLocalName(element);
		BeanDefinitionParser parser = this.parsers.get(localName);
		if (parser == null) {
			parserContext.getReaderContext().fatal(
					"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
		}
		return parser;
	}

  为什么要获取BeanDefinitionParser ，因为BeanDefinitionParser 类是解析配置文件中的<context:component-scan>,<aop:config>等标签，但是不同的标签是由不同的BeanDefinitionParser来进行解析的，如图所示：


  


   接下来我们开始解析这个标签， <context:component-scan>标签的解析是由ComponentScanBeanDefinitionParser类解析的，接下来我们要分析它怎么解析注解的Bean，并把Bean注册到Bean工厂，源代码如下：

  

 public BeanDefinition parse(Element element, ParserContext parserContext) {
        //获取context:component-scan 配置的属性base-package的值
		String[] basePackages = StringUtils.tokenizeToStringArray(element.getAttribute(BASE_PACKAGE_ATTRIBUTE),
				ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
        //创建扫描对应包下的class文件的对象
		ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
        //扫描对应包下的class文件并有注解的Bean包装成BeanDefinition
		Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
		registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
		return null;
	}

说明：

    （1）获取context:component-scan 配置的属性base-package的值，然后放到数组。

    （2）创建扫描对应包下的class和jar文件的对象ClassPathBeanDefinitionScanner ，由这个类来实现扫描包下的class和jar文件并把注解的Bean包装成BeanDefinition。

    （3）BeanDefinition注册到Bean工厂。

 

 第一：扫描是由ComponentScanBeanDefinitionParser的doScan方法来实现的，源代码如下：

    
	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        //新建队列来保存BeanDefinitionHolder
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
        //循环需要扫描的包
		for (String basePackage : basePackages) {
            //进行扫描注解并包装成BeanDefinition
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
                    //对BeanDefinition进行注册
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}
  

   进行扫描注解并包装成BeanDefinition是ComponentScanBeanDefinitionParser由父类ClassPathScanningCandidateComponentProvider的方法findCandidateComponents实现的，源代码如下：

     
 public Set<BeanDefinition> findCandidateComponents(String basePackage) {
		Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();
		try {
           //base-package中的值替换为classpath*:cn/test/**/*.class
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolveBasePackage(basePackage) + "/" + this.resourcePattern;
            //获取所以base-package下的资源
			Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
            boolean traceEnabled = logger.isTraceEnabled();
			boolean debugEnabled = logger.isDebugEnabled();
			for (Resource resource : resources) {
				if (traceEnabled) {
					logger.trace("Scanning " + resource);
				}
				if (resource.isReadable()) {
					try {
						MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
                         //对context:exclude-filter进行过滤
						if (isCandidateComponent(metadataReader)) {
                           //包装BeanDefinition
							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
							sbd.setResource(resource);
							sbd.setSource(resource);
							if (isCandidateComponent(sbd)) {
								if (debugEnabled) {
									logger.debug("Identified candidate component class: " + resource);
								}
								candidates.add(sbd);
							}
							else {
								if (debugEnabled) {
									logger.debug("Ignored because not a concrete top-level class: " + resource);
								}
							}
						}
						else {
							if (traceEnabled) {
								logger.trace("Ignored because not matching any filter: " + resource);
							}
						}
					}
					catch (Throwable ex) {
						throw new BeanDefinitionStoreException(
								"Failed to read candidate component class: " + resource, ex);
					}
				}
				else {
					if (traceEnabled) {
						logger.trace("Ignored because not readable: " + resource);
					}
				}
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
		}
		  return candidates;
	}

说明：

     (1)先根据context:component-scan 中属性的base-package="cn.test"配置转换为classpath*:cn/test/**/*.class，并扫描对应下的class和jar文件并获取类对应的路径，返回Resources

     (2)根据<context:exclude-filter>指定的不扫描包，<context:exclude-filter>指定的扫描包配置进行过滤不包含的包对应下的class和jar。

    （3）封装成BeanDefinition放到队列里。

   

   1）怎么根据packageSearchPath获取包对应下的class路径，是通过PathMatchingResourcePatternResolver类，findAllClassPathResources(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()));获取配置包下的class路径并封装成Resource，实现也是getClassLoader().getResources(path);实现的。源代码如下：

       

<span style="font-size:18px;">public Resource[] getResources(String locationPattern) throws IOException {
		Assert.notNull(locationPattern, "Location pattern must not be null");
		if (locationPattern.startsWith(CLASSPATH_ALL_URL_PREFIX)) {
			// a class path resource (multiple resources for same name possible)
			if (getPathMatcher().isPattern(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()))) {
				// a class path resource pattern
				return findPathMatchingResources(locationPattern);
			}
			else {
				// all class path resources with the given name
				return findAllClassPathResources(locationPattern.substring(CLASSPATH_ALL_URL_PREFIX.length()));
			}
		}
		else {
			// Only look for a pattern after a prefix here
			// (to not get fooled by a pattern symbol in a strange prefix).
			int prefixEnd = locationPattern.indexOf(":") + 1;
			if (getPathMatcher().isPattern(locationPattern.substring(prefixEnd))) {
				// a file pattern
				return findPathMatchingResources(locationPattern);
			}
			else {
				// a single resource with the given name
				return new Resource[] {getResourceLoader().getResource(locationPattern)};
			}
		}
	}

protected Resource[] findAllClassPathResources(String location) throws IOException {
		String path = location;
		if (path.startsWith("/")) {
			path = path.substring(1);
		}
		Enumeration<URL> resourceUrls = getClassLoader().getResources(path);
		Set<Resource> result = new LinkedHashSet<Resource>(16);
		while (resourceUrls.hasMoreElements()) {
			URL url = resourceUrls.nextElement();
			result.add(convertClassLoaderURL(url));
		}
		return result.toArray(new Resource[result.size()]);
	}
</span>

    说明：getClassLoader().getResources获取classpath*:cn/test/**/*.class下的cn/test包下的class的路径信息。并返回了URL。这里能把对应class路径获取到了，就能获取里面的信息。

     

  2）isCandidateComponent实现的标签是里配置的<context:exclude-filter>指定的不扫描包，<context:exclude-filter>指定的扫描包的过滤，源代码如下：

      

<span style="font-size:18px;">protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
		for (TypeFilter tf : this.excludeFilters) {
			if (tf.match(metadataReader, this.metadataReaderFactory)) {
				return false;
			}
		}
		for (TypeFilter tf : this.includeFilters) {
			if (tf.match(metadataReader, this.metadataReaderFactory)) {
				AnnotationMetadata metadata = metadataReader.getAnnotationMetadata();
				if (!metadata.isAnnotated(Profile.class.getName())) {
					return true;
				}
				AnnotationAttributes profile = MetadataUtils.attributesFor(metadata, Profile.class);
				return this.environment.acceptsProfiles(profile.getStringArray("value"));
			}
		}
		return false;
	}</span>

说明： this.excludeFilters有pattern属性，值是就是<context:exclude-filter type="regex" expression="cn.test.*.*.controller"/>的cn.test.*.*.controller值this.pattern.matcher(metadata.getClassName()).matches();通过这个去匹配，如果是就返回false。如图所示：

  


我们到这边已经把对应的通过在XML配置把注解扫描解析并封装成BeanDefinition。

   接下来我们来分析一下注册到Bean工厂，大家还记得ComponentScanBeanDefinitionParser的doScan方法，然后到工厂的是由registerBeanDefinition(definitionHolder, this.registry);实现的，源代码如下：

    
 protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
	}

  public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// Register bean definition under primary name.
		String beanName = definitionHolder.getBeanName();
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// Register aliases for bean name, if any.
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String aliase : aliases) {
				registry.registerAlias(beanName, aliase);
			}
		}
	}

	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		Assert.hasText(beanName, "Bean name must not be empty");
		Assert.notNull(beanDefinition, "BeanDefinition must not be null");

		if (beanDefinition instanceof AbstractBeanDefinition) {
			try {
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}

		synchronized (this.beanDefinitionMap) {
			Object oldBeanDefinition = this.beanDefinitionMap.get(beanName);
			if (oldBeanDefinition != null) {
				if (!this.allowBeanDefinitionOverriding) {
					throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
							"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
							"': There is already [" + oldBeanDefinition + "] bound.");
				}
				else {
					if (this.logger.isInfoEnabled()) {
						this.logger.info("Overriding bean definition for bean '" + beanName +
								"': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");
					}
				}
			}
			else {
				this.beanDefinitionNames.add(beanName);
				this.frozenBeanDefinitionNames = null;
			}
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}

		resetBeanDefinition(beanName);
	}

说明：DefaultListableBeanFactory要实现的保存到Map<String, BeanDefinition> beanDefinitionMap中 以BeanName为key，如果有，就不用保存了。DefaultListableBeanFactory我们在上一篇SpringMVC 源代码深度解析 IOC容器（Bean 解析、注册）有介绍过了，DefaultListableBeanFactory继承了BeanFactory。


总结：

     （1）因为解析注解的到注册，也是先读取配置文件并解析，在解析时扫描对应包下的JAVA类，里面有DefaultBeanDefinitionDocumentReader这个类，doRegisterBeanDefinitions这个方法实现解析配置文件的Bean，这边已经读取进来形成Document 形式存储。然后注解属于扩展的标签，是由NamespaceHandler和BeanDefinitionParser来解析。

   （2）根据context:component-scan中属性base-package去扫描指定包下的class和jar文件，获取对应的路径信息，然后根据配置<context:exclude-filter>指定的扫描包配置进行过滤不包含的包对应下的class和jar路径的Resources。

     （3）把标示@Controller标注web控制器，@Service标注Servicec层的服务，@Respository标注DAO层的数据访问等注解路径都获取包装成BeanDefinition，并注册为Bean类放到Bean工厂，也就是DefaultListableBeanFactoryMap<String, BeanDefinition> beanDefinitionMap中以BeanName为key。



    



 

springMvc+spring+Mybatis 框架搭建
CN-LILU的博客
01-03 535
该项目是maven +springMvc+spring+Mybatis +jdk7+tomcat8项目结构： 1. 先引入pom<!-- MySQL驱动 --> <!-- mysql-connector-java-5.1.43-bin.jar --> <dependency> <groupId>mysql</
一文了解 - -＞ SpringMVC
架构师小吴的博客
06-07 1743
Spring MVC 是由Spring官方提供的基于MVC设计理念的web框架。SpringMVC是基于Servlet封装的用于实现MVC控制的框架，实现前端和服务端的交互。在一个控制器类中可以定于多个方法处理不同的请求在每个方法上添加用于声明当前方法请求的url/**** 1.创建一个类实现Converter接口，泛型指定从什么类型转换为什么类型* 2.实现convert转换方法*/
Spring MVC 解读——<context:component-scan/>
weixin_33831196的博客
02-26 208
2019独角兽企业重金招聘Python工程师标准>>> ...
5.SpringMVC源码关于annotation扫描3
拯救大白程序猿的博客
04-25 958
扫描器加载basePackages 再次回顾，ComponentScanBeanDefinitionParser这个类中的parse()，之前描述了配置扫描器configureScanner()，我们接着了解一下扫描器是如何加载这些包类的。 @Override public BeanDefinition parse(Element element, ParserContext parserC...
spring 源码分析 学习总结
dcxmaozi的博客
11-19 329
spring源码解析和时序图 IOC容器创建主要分为创建容器、 bean的扫描、容器初始化、获取bean、创建bean几个步骤，下面以AnnotationConfigApplicationContext（）容器初始化为入口解析整个IOC容器创建的过程。 1、创建容器 容器创建测试代码入口 public static void main(String[] args) { ...
Spring组件扫描<context:component-scan/>使用详解
热门推荐
12-03 12万+
1.如果不想在xml文件中配置bean，我们可以给我们的类加上spring组件注解，只需再配置下spring的扫描器就可以实现bean的自动载入。 2.下面是引用spring framework开发手册中的一段话“ Spring 2.5引入了更多典型化注解(stereotype annotations)： @Component、@Service和 @Cont
spring注解注入:<context:component-scan>详解
流浪的虾壳
12-24 3132
spring从2.5版本开始支持注解注入，注解注入可以省去很多的xml配置工作。由于注解是写入java代码中的，所以注解注入会失去一定的灵活性，我们要根据需要来选择是否启用注解注入。 我们首先看一个注解注入的实际例子，然后再详细介绍context:component-scan的使用。 如果你已经在用spring mvc的注解配置，那么你一定已经在使用注解注入了，本文不会涉及到sprin
一、实验步骤 1、创建maven web项目或者模块，导入相关软件的依赖包。 2、进行tomcat的相关配置。 3、在数据库mybatis中创建book表，并插入一条数据，sql语句如下： USE mybatis; CREATE TABLE `tb_book` ( `id` int(11) , `name` varchar(32) , `press` varchar(32) , `author` varchar(32) ); INSERT INTO `tb_book` VALUES (1, 'Java EE企业级应用开发教程', '人民邮电出版社', '黑马程序员'); 4、在src/main/java里创建com包，在里面创建itheima子包，在itheima包中分别创建controller,service,dao和domain包。 5、在domain包下创建名称为Book的实体类。代码如下： public class Book { private Integer id; //图书id private String name; //图书名称 private String press; //出版社 private String author; //作者 //getter和setter方法自行补充 @Override public String toString() { return super.toString(); } } 6、在dao包下创建接口BookMapper，里面创建一个根据id查询图书信息的方法，代码如下： public interface BookMapper { public Book findBookById(Integer id); } 7、在src/main/resources文件夹中，创建多级文件夹com/itheima/dao，在dao文件夹下，创建映射文件BookMapper.xml，记录与findBookById对应的sql语句。 <?xml version="1.0" encoding="utf-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.itheima.dao.BookMapper"> <!--根据id查询图书信息 --> <select id="findBookById" parameterType="int" resultType="com.itheima.domain.Book"> select * from tb_book where id = #{id} </select> </mapper> 8、在service包里创建BookService接口，在BookService接口中定义findBookById()方法，通过id获取对应的Book信息。代码如下： public interface BookService { public Book findBookById(Integer id); } 9、在service包中创建子包impl，在ipml包中创建BookServiceImpl类，BookServiceImpl类实现BookService接口的findBookById()方法，并在类中注入一个BookMapper对象。findBookById()方法通过注入的BookMapper对象调用findBookById()方法，根据id查询对应的图书信息。代码如下： public class BookServiceImpl implements BookService { @Autowired private BookMapper bookMapper; public Book findBookById(Integer id) { return bookMapper.findBookById(id); } } 10、在controller包中创建BookController类，在BookController类中注入一个BookService对象，并且定义一个名称为findBookById()的方法。findBookById()方法获取传递过来的图书id，并将图书id作为参数传递给BookService对象调用的findBookById()方法。代码如下： @Controller public class BookController { @Autowired private BookService bookService; @RequestMapping("/book") public ModelAndView findBookById(Integer id) { Book book = bookService.findBookById(id); ModelAndView modelAndView = new ModelAndView(); modelAndView.setViewName("book"); modelAndView.addObject("book", book); return modelAndView; } } 11、在resources文件夹中创建jdbc.properties,作为数据库连接配置文件，代码如下： jdbc.driverClassName=com.mysql.cj.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true\ &characterEncoding=utf-8&serverTimezone=Asia/Shanghai jdbc.username=root jdbc.password=root 12、在resources文件夹中创建Spring的配置文件application-dao.xml文件，用于扫描包，引入数据库连接配置文件，配置Spring和MyBatis的整合信息(包括SqlSessionFactoryBean类和MapperScannerConfigurer的配置)。代码如下： <!--开启注解扫描, 扫描包--> <context:component-scan base-package="com.itheima.service"/> <!--引入属性文件--> <context:property-placeholder location="classpath:jdbc.properties"/> <!--数据源--> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driverClassName" value="${jdbc.driverClassName}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </bean> <!--创建SqlSessionFactory对象--> <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <!--数据源--> <property name="dataSource" ref="dataSource"/> </bean> <!--扫描Dao包，创建动态代理对象,会自动存储到spring IOC容器中--> <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <!--指定要扫描的dao的包--> <property name="basePackage" value="com.itheima.dao"/> </bean> 13、在src/test/java目录下，创建名称为BookTest的测试类，用于对Spring和MyBatis的整合进行测试。用上@RunWith和@ContextConfiguration注解，代码如下,对此方法进行测试，成功打印出书籍信息即可证明Spring和MyBatis整合成功。 @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations ="classpath:application-dao.xml") public class BookTest { @Autowired private BookService bookService; @Test public void findBookById() { Book book = bookService.findBookById(1); System.out.println("图书id:" + book.getId()); System.out.println("图书名称:" + book.getName()); System.out.println("作者:" + book.getAuthor()); System.out.println("出版社:" + book.getPress()); } } 14、下面对Spring和SpringMVC进行整合。在resources目录下创建Spring MVC的配置文件spring-mvc.xml，负责扫描controller层以及配置视图解析器。代码如下： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" 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 http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- 配置要扫描的包 --> <context:component-scan base-package="com.itheima.controller"/> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="suffix" value=".jsp"/> </bean> <!-- 配置默认Servlet，处理静态资源 --> <mvc:default-servlet-handler/> <!-- 配置注解驱动 --> <mvc:annotation-driven/> </beans> 15、在项目的web.xml中配置Spring的监听器ContextLoaderListener来加载Spring容器及Spring的配置文件，具体配置如下所示： <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:application-*.xml</param-value> </context-param> <listener> <listener-class> org.springframework.web.context.ContextLoaderListener</listener-class> </listener> 16、接着在web.xml中配置SpringMVC的前端控制器，并在初始化前端控制器时加载Spring MVC的的配置文件spring-mvc.xml。代码如下： <!--Spring MVC 前端控制器--> <servlet> <servlet-name>DispatcherServlet</servlet-name> <servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class> <!--初始化参数--> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:spring-mvc.xml</param-value> </init-param> <!--项目启动时候，初始化前端控制器--> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>DispatcherServlet</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> 17、在webapp目录下创建book.jsp，代码如下： <%@ page contentType="text/html;charset=UTF-8" language="java" isELIgnored="false" %> <html> <head><title>图书信息查询</title></head> <body> <table border="1"> <tr> <th>图书id</th> <th>图书名称</th> <th>出版社</th> <th>作者</th> </tr> <tr> <td>${book.id}</td> <td>${book.name}</td> <td>${book.press}</td> <td>${book.author}</td> </tr> </table> </body> </html> 18、运行项目，在浏览器地址栏中输入http://localhost/book?id=1来进行图书查询。如果能顺利访问，表示SSM整合成功（如果你端口不是80的话，访问url得加上端口）。 用idea按照以上流程，详细的列出每一步的步骤，教会小白。
最新发布
06-07
- **注解失效**：确保 `<context:component-scan>` 包路径正确 - **SQL异常**：检查MyBatis映射文件路径和数据库连接参数 - **404错误**：确认JSP文件在 `/WEB-INF/views/` 目录下 > **关键点**：Spring容器（由 `...
<?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.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- 缩小扫描范围到 com.itheima.SpringMVC --> <context:component-scan base-package="com.itheima.SpringMVC"/> <bean id="User" class="com.itheima.SpringMVC.pojo.User"> <property name="username" value="涂大钧"></property> <property name="password" value="123"></property> </bean> <!--数据源--> <context:property-placeholder location="classpath*:jdbc.properties"/> <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"> <property name="driverClassName" value="${jdbc.driver}"/> <property name="url" value="${jdbc.url}"></property> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </bean> <!--配置sql--> <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"></property> <!--别名扫包--> <property name="typeAliasesPackage" value="com.itheima.SpringMVC.pojo"></property> <!--指定XML文件位置--> <!--mybatis-config.xml--> <property name="configLocation" value="classpath:/mybatis-mvc-config.xml" /> </bean> <!--指定Mapper XML文件位置--> <!--扫描Mapper--> <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property> <property name="basePackage" value="com.itheima.SpringMVC.Mapper"></property> </bean> <!-- 事务管理器--> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"></property> </bean> <!--开启注解驱动的事务管理--> <tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven> </beans><?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> <!-- 引入外部配置文件 --> <properties resource="jdbc.properties"> <!-- 可以在这里添加默认属性值 --> </properties> <!-- 设置 MyBatis 核心配置 --> <settings> <!-- 开启驼峰命名自动映射，如将数据库字段 user_name 映射到 Java 属性 userName --> <setting name="mapUnderscoreToCamelCase" value="true"/> <!-- 开启二级缓存 --> <setting name="cacheEnabled" value="true"/> <!-- 开启延迟加载 --> <setting name="lazyLoadingEnabled" value="true"/> <!-- 开启 aggressiveLazyLoading 会导致所有关联对象在被访问时立即加载 --> <setting name="aggressiveLazyLoading" value="true"/> <!-- 配置日志实现 --> <setting name="logImpl" value="STDOUT_LOGGING"/> </settings> <!-- 配置类型别名，简化映射 --> <typeAliases> <package name="com.itheima.SpringMVC.pojo"/> </typeAliases> <!-- 配置插件 --> <plugins> <!-- PageHelper 分页插件 --> <plugin interceptor="com.github.pagehelper.PageInterceptor"> <!-- 可选配置 --> <property name="reasonable" value="true"/> <property name="supportMethodsArguments" value="true"/> <property name="params" value="count=countSql"/> </plugin> </plugins> <!-- 配置数据库环境 --> <environments default="development"> <environment id="development"> <!-- 使用 JDBC 事务管理器 --> <transactionManager type="JDBC"/> <!-- 配置数据源，使用 POOLED 连接池 --> <dataSource type="POOLED"> <property name="driver" value="${jdbc.driver}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> <!-- 可选配置：连接池参数 --> <property name="poolMaximumActiveConnections" value="10"/> <property name="poolMaximumIdleConnections" value="5"/> </dataSource> </environment> </environments> <!-- 注册映射器 --> <mappers> <package name="com.itheima.SpringMVC.Mapper" /> <!-- <mapper resource="SpringMVC/Mapper/UsersMapper.xml"/>--> <!-- <mapper resource="SpringMVC/Mapper/UserMapper.xml"/>--> <!-- <mapper resource="SpringMVC/Mapper/IdCardMapper.xml"/>--> <!-- <mapper resource="SpringMVC/Mapper/GoodsMapper.xml"/>--> <!-- <mapper resource="SpringMVC/Mapper/GoodsTypeMapper.xml"/>--> <!-- <mapper resource="SpringMVC/Mapper/OrdersMapper.xml"/>--> <!-- <mapper resource="SpringMVC/Mapper/OrderItemsMapper.xml"/>--> </mappers> </configuration>有问题吗
05-30
如果使用XML配置，检查<context:component-scan>的base-package是否正确，是否覆盖了Mapper接口所在的包。2.**MyBatis的MapperXML配置**：查看mybatis-config.xml中的<mappers>部分，是否通过resource或class正确...
好的，我现在要帮助这个用户完成他的毕业设计——基于SSM的在线音乐播放系统。用户是Java新手，没有任何基础，时间只有两个月，所以需要详细的开发流程和教程。首先，我需要理清整个项目的结构和步骤，确保每一步都清晰易懂。 用户提到的系统功能分为三块：用户管理、音乐管理、音乐播放。我应该从最基础的环境搭建开始，然后逐步引导他完成各个模块的开发。首先，得确保他安装好必要的开发工具，比如JDK、Maven、Tomcat、MySQL和IDEA。接下来是创建Maven项目，配置SSM框架，这可能会涉及到pom.xml的依赖管理，以及Spring、Spring MVC和MyBatis的配置文件。 然后，用户管理模块需要设计数据库表，比如用户表的结构，包括用户名、密码等字段。接着是实体类、DAO层、Service层和Controller层的代码编写。这里要详细说明每个部分的作用，并提供示例代码。可能需要解释MyBatis的Mapper接口和XML映射文件的使用。 音乐管理模块涉及文件上传和存储，这里需要指导用户如何处理音乐文件的上传，存储路径的配置，以及数据库中的音乐信息管理。同时，音乐播放功能需要前端页面的支持，比如使用HTML5的audio标签，以及后端提供音乐文件流的接口。 考虑到用户的时间有限，每个步骤都需要详细但不过于复杂，避免让他感到困惑。可能需要分阶段指导，比如先完成环境搭建和项目配置，然后逐步实现各个功能模块。同时，要提醒他在开发过程中注意常见错误，比如依赖冲突、配置错误，以及文件路径的问题。 另外，用户可能对SSM框架不熟悉，所以需要解释每个框架的作用和它们之间的整合方式。例如，Spring的IoC和AOP，Spring MVC的控制器和视图解析，MyBatis的数据持久化等。通过简单的示例和注释，帮助他理解各个组件之间的关系。 最后，测试和部署也是重要的部分。需要指导他如何使用Postman测试接口，如何将项目打包成WAR文件并部署到Tomcat服务器上。可能还需要介绍一些基本的调试技巧，比如查看日志、断点调试等。 总之，我需要将整个开发流程分解成多个小步骤，每个步骤都提供详细的教程和代码示例，确保用户能够逐步跟进，顺利完成毕设。同时，语言要简洁明了，避免使用专业术语，或者在使用时进行解释，以符合他作为新手的理解水平。 以下是为您规划的2个月开发计划，今天我们先开始第一部分：环境搭建与项目初始化 # 一、第1周：环境准备与项目创建（建议用时3天） ## 1. 开发环境安装（必须严格按版本安装） ```markdown 1. JDK 1.8（官网下载安装，配置JAVA_HOME环境变量） 2. Apache Maven 3.6.3（配置MAVEN_HOME和仓库路径） 3. Tomcat 9（解压即可用） 4. MySQL 5.7（建议使用XAMPP集成环境） 5. IntelliJ IDEA 2023社区版（免费） ``` ## 2. 创建Maven项目（图文教程） 步骤： 1. 打开IDEA → New Project → Maven → 勾选`Create from archetype`选择`maven-archetype-webapp` 2. GroupId填`com.yourname`，ArtifactId填`music-system` 3. 确认项目路径 → 完成创建 ## 3. 基础pom.xml配置（复制即可） ```xml <dependencies> <!-- Spring核心 --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.3.18</version> </dependency> <!-- MyBatis --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.7</version> </dependency> <!-- MySQL驱动 --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.27</version> </dependency> <!-- JSP支持 --> <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>4.0.1</version> <scope>provided</scope> </dependency> </dependencies> ``` ## 4. 目录结构调整（必须严格遵循） ```bash src ├── main │ ├── java │ │ └── com │ │ └── yourname │ │ ├── controller │ │ ├── service │ │ ├── dao │ │ └── pojo │ ├── resources │ │ ├── spring │ │ │ ├── applicationContext.xml │ │ │ └── spring-mvc.xml │ │ └── mybatis-config.xml │ └── webapp │ ├── WEB-INF │ │ └── views │ └── static │ ├── css │ ├── js │ └── uploads ``` 下一步建议：是否需要我详细讲解每个配置文件的作用？或者您想先创建数据库？请告诉我您当前的进度和疑问。 下一步我该做什么
03-08
<context:component-scan base-package="com.yourname.controller"/> <!-- 视图解析器 --> <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> <property name="prefix" ...
【SpringMVC】配置<context:component-scan>
baidu_21780935的博客
03-09 7419
当我们启动一个web项目时，容器（tomcat）会先读取项目web.xml配置文件的配置，这一步骤完成后项目才正常启动。 在web.xml文件中的节点加载是有顺序， -> -> -> 相同元素按照先后顺序加载。 我们首先在在web.xml中通过contextConfigLocation配置spring，contextConfigLocation定义spring配
＜context:component-scan/＞ 扫描指定的包中的类上的注解, 常用的注解
penggerhe的博客
09-08 606
< context:component-scan/> 扫描指定的包中的类上的注解，常用的注解有： @Controller 声明Action组件 @Service 声明Service组件 @Service(“myMovieLister”) @Repository 声明Dao组件 @Component 泛指组件, 当不好归类时. @RequestMapping("/menu") 请求映射 @Resource 用于注入，( j2ee提供的 ) 默认按名称装配，@Resource(n
[spring-mvc] <context:component-scan>使用说明
weixin_36210698的博客
05-22 760
在xml配置了这个标签后，spring可以自动去扫描base-package下面或者子包下面的javar文件，如果扫描到了有@Component @Controller @RestController @ControllerAdvice @RestControllerAdvice @Repository @Service @Configuration等这些注解的类，则把这些类注册为bean注意如果配
springMVC之配置（context:component-scan） 详解
huawen6的专栏
04-16 5291
<context:component-scan base-package="com.wjx.betalot" <!-- 扫描的基本包路径 --> annotation-config="true" <!-- 是否激活属性注入注解 --> name-generator="or...
spring组件扫描<context:component-scan/>详解
qazwsx081的专栏
02-26 1404
我们通过spring的以下方式去扫描com.test.scan.core包下所有类中的一下注解：@Repository、@Service、@Controller、@Component、@Configuration   Java代码      package="com.test.scan.core" />    在特殊的情况下，比如一个项目涉及到多个数据源，
Spring源码系列（二）——@ComponentScan源码解析
犀利的小牛
12-24 1788
首先看一下本次用到的简单的示例代码 StudentA用@Component注解标识 Config用@ComponentScan标识，扫描的基础包路径为：com.kennor.test 最后Test运行的示例代码如下： public static void main(String[] args) { AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Config
spring概念简介、bean扫描与注册实现方式
weixin_34240520的博客
07-25 103
2019独角兽企业重金招聘Python工程师标准>>> ...
context:component-scan属性介绍，SSM的bean被扫描两次问题
Java小皮孩
09-25 8073
context:component-scan属性 ​  默认情况下，context:component-scan扫描包中注解所标 注的类，如@Compone
context:component-scan使用说明
别抢我蓝buff
03-25 376
https://www.cnblogs.com/fightingcoding/p/component-scan.html https://blog.csdn.net/chunqiuwei/article/details/16115135 默认情况下，<context:component-scan>...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码农_程序员

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值