等我下课

Spring注解驱动开发

IOC

组件注册-@Configuration&@Bean给容器中注册组件

修改pom文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.atguigu</groupId>
  <artifactId>spring-annotation</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
  <dependencies>
  	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-context</artifactId>
	    <version>4.3.12.RELEASE</version>
	</dependency>
  </dependencies>
</project>

如果

创建一个实体类

package com.atguigu.bean;

public class Person {
	private String name;
	private Integer age;
	
	public Person() {
		super();
	}
	
	public Person(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
}

以前的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.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	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 http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">


	<bean id="person" class="com.atguigu.bean.Person">
		<property name="age" value="18"></property>
		<property name="name" value="zhangsan"></property>
	</bean>
	

</beans>

package com.atguigu;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.atguigu.bean.Person;
import com.atguigu.config.MainConfig;

public class MainTest {

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
		Person person = (Person)applicationContext.getBean("person");
		System.out.println(person);
	}
}

@Bean注解方式

package com.atguigu.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.atguigu.bean.Person;

/**
 * 配置类
 * 等同于以前的配置文件
 */
@Configuration  //告诉Spring这是一个配置类
public class MainConfig {
	
	//给容器中注册一个Bean,类型为返回值的类型，id默认是用方法名作为id  
	@Bean
	public Person person() {
		return new Person("lisi",20);
	}
	
}

package com.atguigu;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.atguigu.bean.Person;
import com.atguigu.config.MainConfig;

public class MainTest {

	public static void main(String[] args) {
//		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
//		Person person = (Person)applicationContext.getBean("person");
//		System.out.println(person);
		ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
		Person person = applicationContext.getBean(Person.class);
		System.out.println(person);
	}
	
}

@Bean（“person02”）还可以为Bean的类型名取名

组件注册-@ComponentScan-自动扫描组件&指定扫描规则

以前的xml扫描

<!-- 包扫描、只要标注了@Controller、@Service、@Repository，@Component -->
	<context:component-scan base-package="com.atguigu"></context:component-scan>

等同于注解

@ComponentScan(value = "com.atguigu"）

BookController

package com.atguigu.controller;

import org.springframework.stereotype.Controller;

@Controller
public class BookController {

}

BookDao

package com.atguigu.dao;

import org.springframework.stereotype.Repository;

@Repository
public class BookDao {

}

BookService

package com.atguigu.service;

import org.springframework.stereotype.Service;

@Service
public class BookService {

}

MainConfig

package com.atguigu.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;

import com.atguigu.bean.Person;

/**
 * 配置类
 * 等同于以前的配置文件
 */
@Configuration  //告诉Spring这是一个配置类
@ComponentScan(value = "com.atguigu")
public class MainConfig {
	
	//给容器中注册一个Bean,类型为返回值的类型，id默认是用方法名作为id  
	@Bean
	public Person person() {
		return new Person("lisi",20);
	}
	
}

IOCTest

package com.atguigu.test;

import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.atguigu.config.MainConfig;

public class IOCTest {
	
	
	@SuppressWarnings("resource")
	@Test
	public void test01() {
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
		String[] definitionNames = applicationContext.getBeanDefinitionNames();
		for (String name : definitionNames) {
			System.out.println(name);
		}
	}
}

@ComponentScan

includeFilters: 只扫描哪些
excludeFilters：排除哪些

excludeFilters

ANNOTATION：按注解排除
ASPECTJ：按ASPECTJ表达式排除
ASSIGNABLE_TYPE：按类型排除
CUSTOM：按自定义排除
REGEX：按正则表达式排除

例如使用ANNOTATION

package com.atguigu.config;

import java.security.Provider.Service;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;

import com.atguigu.bean.Person;

/**
 * 配置类
 * 等同于以前的配置文件
 */
@Configuration  //告诉Spring这是一个配置类
@ComponentScan(value = "com.atguigu",excludeFilters = {
		@Filter(type=FilterType.ANNOTATION,classes={Controller.class,Service.class})
})
public class MainConfig {
	
	//给容器中注册一个Bean,类型为返回值的类型，id默认是用方法名作为id  
	@Bean
	public Person person() {
		return new Person("lisi",20);
	}
	
}

includeFilters

以前在xml中必须配置禁用默认的过滤规则

	<!-- 包扫描、只要标注了@Controller、@Service、@Repository，@Component -->
	<context:component-scan base-package="com.atguigu" use-default-filters="false"></context:component-scan>

注解
useDefaultFilters = false

package com.atguigu.config;

import java.security.Provider.Service;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;

import com.atguigu.bean.Person;

/**
 * 配置类
 * 等同于以前的配置文件
 */
@Configuration  //告诉Spring这是一个配置类
@ComponentScan(value = "com.atguigu",includeFilters = {
		@Filter(type=FilterType.ANNOTATION,classes={Controller.class})
},useDefaultFilters = false)
public class MainConfig {
	
	//给容器中注册一个Bean,类型为返回值的类型，id默认是用方法名作为id  
	@Bean
	public Person person() {
		return new Person("lisi",20);
	}
	
}

只有controller

@ComponentScan是重复注解，可以多次使用，或者使用@ComponentScans

@ComponentScans(
	value = {@ComponentScan(value = "com.atguigu",includeFilters = {
			@Filter(type=FilterType.ANNOTATION,classes={Controller.class})
	},useDefaultFilters = false)
	}
)

FilterType.ASSIGNABLE_TYPE

@ComponentScans(
	value = {@ComponentScan(value = "com.atguigu",includeFilters = {
			@Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
			@Filter(type=FilterType.ASSIGNABLE_TYPE,classes={BookService.class})
	},useDefaultFilters = false)
	}
)

FilterType.CUSTOM

@ComponentScans(
	value = {@ComponentScan(value = "com.atguigu",includeFilters = {
			@Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})
	},useDefaultFilters = false)
	}
)

package com.atguigu.config;

import java.io.IOException;

import org.springframework.core.io.Resource;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;

public class MyTypeFilter implements TypeFilter {

	/**
	 * metadataReader:读取到的当前正在扫描的类的信息
	 * metadataReaderFactory：不止当前类，可以获取到其他任何类信息
	 */
	@Override
	public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
			throws IOException {
		//获取当前类注解的信息
		AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
		//获取当前正在扫描的类的类信息
		ClassMetadata classMetadata = metadataReader.getClassMetadata();
		//获取当前类资源(例如类的路径)
		Resource resource = metadataReader.getResource();
		
		//类名
		String className = classMetadata.getClassName();
		System.out.println("--->"+className);
		
		return false;
	}

}

只要当前处理到哪个类，类的信息都可以获取的到

获取到这些类的信息，我们就可以做判断，满足条件的返回true.

package com.atguigu.config;

import java.io.IOException;

import org.springframework.core.io.Resource;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;

public class MyTypeFilter implements TypeFilter {

	/**
	 * metadataReader:读取到的当前正在扫描的类的信息
	 * metadataReaderFactory：不止当前类，可以获取到其他任何类信息
	 */
	@Override
	public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
			throws IOException {
		//获取当前类注解的信息
		AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
		//获取当前正在扫描的类的类信息
		ClassMetadata classMetadata = metadataReader.getClassMetadata();
		//获取当前类资源(例如类的路径)
		Resource resource = metadataReader.getResource();
		
		//类名
		String className = classMetadata.getClassName();
		System.out.println("--->"+className);
		
		//指定一个规则
		if(className.contains("er")) {
			return true;
		}
		return false;
	}

}

这些都包含er

组件注册-@Scope-设置组件作用域

package com.atguigu.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.atguigu.bean.Person;

@Configuration
public class MainConfig2 {

	
	@Bean("person")
	public Person person() {
		return new Person("张三",25);
	}
	
}

package com.atguigu.test;

import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.atguigu.config.MainConfig2;

public class IOCTest {
	
	
	@SuppressWarnings("resource")
	@Test
	public void test01() {
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);
		String[] definitionNames = applicationContext.getBeanDefinitionNames();
		for (String name : definitionNames) {
			System.out.println(name);
		}
		
		Object bean = applicationContext.getBean("person");
		Object bean2 = applicationContext.getBean("person");
		//输出一下，两个对象是否相等
		System.out.println(bean == bean2);
	}
}

是相等的，默认是单实例。

@Scope

参数：

prototype: 多实例的、ioc容器启动不会调用方法创建对象，每次获取的时候才会调用方法创建对象。
singleton: 单实例的（默认值）、ioc容器启动会调用方法创建对象放到ioc容器中。以后每次获取就是直接从容器（map.get()）中拿。
request: 同一次请求创建一个实例
session: 同一个session创建一个实例

package com.atguigu.config;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

import com.atguigu.bean.Person;

@Configuration
public class MainConfig2 {

	//默认是单实例的
	/**
	 * ConfigurableBeanFactory#SCOPE_PROTOTYPE   prototype
	 * ConfigurableBeanFactory#SCOPE_SINGLETON   singleton
	 * org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST   request
	 * org.springframework.web.context.WebApplicationContext#SCOPE_SESSION   session
	 * 
	 * prototype: 多实例的
	 * singleton: 单实例的（默认值）
	 * request: 同一次请求创建一个实例
	 * session: 同一个session创建一个实例
	 * @return
	 */
	@Scope("prototype")
	@Bean("person")
	public Person person() {
		return new Person("张三",25);
	}
	
}

组件注册-@Lazy-bean懒加载

懒加载：

单实例bean：默认在容器启动的时候创建对象；
懒加载：容器启动不创建对象。第一次使用（获取）bean创建对象，并初始化。只会创建一次。

package com.atguigu.config;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;

import com.atguigu.bean.Person;

@Configuration
public class MainConfig2 {

	//默认是单实例的
	/**
	 * @Scope
	 * ConfigurableBeanFactory#SCOPE_PROTOTYPE   prototype
	 * ConfigurableBeanFactory#SCOPE_SINGLETON   singleton
	 * org.springframework.web.context.WebApplicationContext#SCOPE_REQUEST   request
	 * org.springframework.web.context.WebApplicationContext#SCOPE_SESSION   session
	 * prototype: 多实例的
	 * singleton: 单实例的（默认值）
	 * request: 同一次请求创建一个实例
	 * session: 同一个session创建一个实例
	 * 
	 * @return
	 * 
	 * @Lazy懒加载
	 */
	@Lazy
	@Bean("person")
	public Person person() {
		return new Person("张三",25);
	}
	
}

组件注册-@Conditional-按照条件注册bean

@Conditional({Condition}): 按照一定的条件进行判断，满足条件给容器中注册bean

package com.atguigu.config;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;

import com.atguigu.bean.Person;
import com.atguigu.condition.LinuxCondition;
import com.atguigu.condition.WindowsCondition;

@Configuration
public class MainConfig2 {


	
	
	/**
	 * @Conditional({Condition}): 按照一定的条件进行判断，满足条件给容器中注册bean
	 * 
	 * 如果系统是windows ，给容器中注册（"bill"）
	 * 如果系统是linux ，给容器中注册（"linux"）
	 */
	@Conditional({WindowsCondition.class})
	@Bean("bill")
	public Person person01() {
		return new Person("Bill Gates",62);
	}
	
	@Conditional({LinuxCondition.class})
	@Bean("linux")
	public Person person02() {
		return new Person("linux",48);
	}
}

@Conditional需要Condition类来判断

WindowsCondition

package com.atguigu.condition;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

//判断系统是否是Windows
public class WindowsCondition implements Condition{
	

	


	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		// 是否Windows系统
		
		//1.能获取到ioc使用的beanFactory
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
		//2.获取类加载器
		ClassLoader classLoader = context.getClassLoader();
		//3.获取当前环境信息
		Environment environment = context.getEnvironment();
		//4.获取到bean定义的注册类
		BeanDefinitionRegistry registry = context.getRegistry();
		
		String property = environment.getProperty("os.name");
		if(property.contains("Windows")) {
			return true;
		}
			
		return false;
	}
	

}

LinuxCondition

package com.atguigu.condition;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

//判断系统是否是Linux 
public class LinuxCondition implements Condition{

	/**
	 * ConditionContext: 判断条件能使用的上下文环境
	 * AnnotatedTypeMetadata: 注释信息
	 */
	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		// 是否linux系统
		
		//1.能获取到ioc使用的beanFactory
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
		//2.获取类加载器
		ClassLoader classLoader = context.getClassLoader();
		//3.获取当前环境信息
		Environment environment = context.getEnvironment();
		//4.获取到bean定义的注册类
		BeanDefinitionRegistry registry = context.getRegistry();
		
		String property = environment.getProperty("os.name");
		if(property.contains("linux")) {
			return true;
		}
		return false;
	}
}

测试

package com.atguigu.test;

import java.util.Map;

import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

import com.atguigu.bean.Person;
import com.atguigu.config.MainConfig2;

public class IOCTest {
	
	AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);

	@Test
	public void test01() {
		
		String[] beanNamesForType = applicationContext.getBeanNamesForType(Person.class);
		ConfigurableEnvironment environment = applicationContext.getEnvironment();
		//动态获取环境变量的值
		String property = environment.getProperty("os.name");
		System.out.println(property);
		for (String name : beanNamesForType) {
			System.out.println(name);
		}

		Map<String, Person> persons = applicationContext.getBeansOfType(Person.class);
		System.out.println(persons);
		
	}
}

再试试Linux,当然我不可能切换操作系统
我们改变一个运行时变量。

不仅可以加在方法上，也可以加在类上。

组件注册-@Import-给容器中快速导入一个组件

给容器中注册组件

包扫描+组件标注注解（@Controller/@Service/Repository/@Component）
@Bean[导入的第三方包里面的组件]
@Import[快速给容器中导入一个组件]

@Import(要导入到容器中的组件)

容器中就会自动注册这个组件，id默认是全类名

导入组件，id默认是组件的全类名

package com.atguigu.bean;

public class Color {

}

package com.atguigu.bean;

public class Red {

}

package com.atguigu.config;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;

import com.atguigu.bean.Color;
import com.atguigu.bean.Person;
import com.atguigu.bean.Red;
import com.atguigu.condition.LinuxCondition;
import com.atguigu.condition.WindowsCondition;

@Configuration
@Import(Color.class) //导入组件，id默认是组件的全类名
public class MainConfig2 {


}

package com.atguigu.test;

import java.util.Map;

import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

import com.atguigu.bean.Person;
import com.atguigu.config.MainConfig2;

public class IOCTest {
	
	AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);

	@Test
	public void testImport() {
		printBeans(applicationContext); 
	}
	
	private void printBeans(AnnotationConfigApplicationContext applicationContext) {
		String[] definitionNames = applicationContext.getBeanDefinitionNames();
		for (String name : definitionNames) {
			System.out.println(name);
		}
	}
	
	
}

导入多个组件

package com.atguigu.config;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;

import com.atguigu.bean.Color;
import com.atguigu.bean.Person;
import com.atguigu.bean.Red;
import com.atguigu.condition.LinuxCondition;
import com.atguigu.condition.WindowsCondition;

@Configuration
//@Import(Color.class) //导入组件，id默认是组件的全类名
@Import({Color.class,Red.class})  //导入多个组件
public class MainConfig2 {


	

}

组件注册-@Import-使用ImportSelector

ImportSelector：返回需要导入的组件的全类名数组

package com.atguigu.bean;

public class Blue {

}

package com.atguigu.bean;

public class Yellow {

}

package com.atguigu.condition;

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

//自定义逻辑返回需要导入的组件
public class MyImportSelector implements ImportSelector{

	//返回值，就是要导入到容器中的组件全类名
	//AnnotationMetadata: 当前标注@Import注解的类的所有注解信息
	@Override
	public String[] selectImports(AnnotationMetadata importingClassMetadata) {
		// TODO Auto-generated method stub
//		importingClassMetadata.get //可以获取了所有注解的信息和所有跟类有关的信息
		//不要返回null值，可以返回空数组new String[]{};
		return new String[] {"com.atguigu.bean.Blue","com.atguigu.bean.Yellow"};
	}

}

package com.atguigu.config;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;

import com.atguigu.bean.Color;
import com.atguigu.bean.Person;
import com.atguigu.bean.Red;
import com.atguigu.condition.LinuxCondition;
import com.atguigu.condition.MyImportSelector;
import com.atguigu.condition.WindowsCondition;

@Configuration
//@Import(Color.class) //导入组件，id默认是组件的全类名
@Import({Color.class,Red.class,MyImportSelector.class})  //导入多个组件
public class MainConfig2 {


	

}

package com.atguigu.test;

import java.util.Map;

import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

import com.atguigu.bean.Person;
import com.atguigu.config.MainConfig2;

public class IOCTest {
	
	AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);

	@Test
	public void testImport() {
		printBeans(applicationContext); 
	}
	
	private void printBeans(AnnotationConfigApplicationContext applicationContext) {
		String[] definitionNames = applicationContext.getBeanDefinitionNames();
		for (String name : definitionNames) {
			System.out.println(name);
		}
	}
	
	
}

组件注册-@Import-使用ImportBeanDefinitionRegistrar

package com.atguigu.condition;

import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

import com.atguigu.bean.RainBow;

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar{

	/**
	 * AnnotationMetadata: 当前类的注解信息以及其他的信息
	 * BeanDefinitionRegistry： BeanDefinition注册类
	 * 		把所有中需要添加到容器中的bean;
	 * 		BeanDefinitionRegistry.registerBeanDefinition(手动注册进来)
	 */
	@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		
		boolean definition = registry.containsBeanDefinition("com.atguigu.bean.Red");
		boolean definition2 = registry.containsBeanDefinition("com.atguigu.bean.Blue");
		if(definition && definition2) {
			//指定bean名
			RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(RainBow.class);
			registry.registerBeanDefinition("rainBow", rootBeanDefinition);
		}
	}

}

package com.atguigu.config;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;

import com.atguigu.bean.Color;
import com.atguigu.bean.Person;
import com.atguigu.bean.Red;
import com.atguigu.condition.LinuxCondition;
import com.atguigu.condition.MyImportBeanDefinitionRegistrar;
import com.atguigu.condition.MyImportSelector;
import com.atguigu.condition.WindowsCondition;

@Configuration
//@Import(Color.class) //导入组件，id默认是组件的全类名
@Import({Color.class,Red.class,MyImportSelector.class,MyImportBeanDefinitionRegistrar.class})  //导入多个组件
public class MainConfig2 {


	

}

package com.atguigu.test;

import java.util.Map;

import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

import com.atguigu.bean.Person;
import com.atguigu.config.MainConfig2;

public class IOCTest {
	
	AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);

	@Test
	public void testImport() {
		printBeans(applicationContext); 
	}
	
	private void printBeans(AnnotationConfigApplicationContext applicationContext) {
		String[] definitionNames = applicationContext.getBeanDefinitionNames();
		for (String name : definitionNames) {
			System.out.println(name);
		}
	}
	
	
}

组件注册-使用FactoryBean注册组件

package com.atguigu.bean;

import org.springframework.beans.factory.FactoryBean;

//创建一个Spring定义的FactoryBean
public class ColorFactoryBean implements FactoryBean<Color>{

	//返回一个Color对象，这个对象会添加到容器中
	@Override
	public Color getObject() throws Exception {

		System.out.println("ColorFactoryBean...getgetObject....");
		return new Color();
	}

	@Override
	public Class<?> getObjectType() {
		System.out.println("ColorFactoryBean...getObjectType....");
		return Color.class;
	}

	//控制是否是单例
	//true:这个bean是单实例，在容器中保存一份
	//false: 多实例，每次获取都会创建一个新的bean
	@Override
	public boolean isSingleton() {
		// TODO Auto-generated method stub
		return true;
	}

}

package com.atguigu.config;

import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.Lazy;
import org.springframework.context.annotation.Scope;

import com.atguigu.bean.Color;
import com.atguigu.bean.ColorFactoryBean;
import com.atguigu.bean.Person;
import com.atguigu.bean.Red;
import com.atguigu.condition.LinuxCondition;
import com.atguigu.condition.MyImportBeanDefinitionRegistrar;
import com.atguigu.condition.MyImportSelector;
import com.atguigu.condition.WindowsCondition;

@Configuration
//@Import(Color.class) //导入组件，id默认是组件的全类名
@Import({Color.class,Red.class,MyImportSelector.class,MyImportBeanDefinitionRegistrar.class})  //导入多个组件
public class MainConfig2 {

	@Bean 
	public ColorFactoryBean colorFactoryBean() {
		return new ColorFactoryBean();
	}

}

package com.atguigu.test;

import java.util.Map;

import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

import com.atguigu.bean.Person;
import com.atguigu.config.MainConfig2;

public class IOCTest {
	
	AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig2.class);

	@Test
	public void testImport() {
		printBeans(applicationContext); 
	}
	
	private void printBeans(AnnotationConfigApplicationContext applicationContext) {
		String[] definitionNames = applicationContext.getBeanDefinitionNames();
		for (String name : definitionNames) {
			System.out.println(name);
		}
		
		Object colorFactoryBean = applicationContext.getBean("colorFactoryBean");
		Object colorFactoryBean2 = applicationContext.getBean("colorFactoryBean");
		System.out.println("colorFactoryBean的类型："+colorFactoryBean.getClass());
		System.out.println(colorFactoryBean == colorFactoryBean2);
		//通过在前面加上& Spring就知道我们是需要工厂bean的本身
		Object colorFactoryBean3 = applicationContext.getBean("&colorFactoryBean");
		System.out.println("&colorFactoryBean的类型："+colorFactoryBean3.getClass());

	}
	
	
}

AOP

【动态代理】

指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；

导入aop模块；Spring AOP

定义一个业务逻辑类（MathCalculator）

package com.atguigu.aop;

/**
 * 数学计算器
 * @author john
 *
 */
public class MathCalculator {

	//除法
	public int div(int i,int j) {
		System.out.println("MathCalculator..........div");
		return i/j;
	}
	
}

我们需要在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常）

日志切面类（LogAspects）

切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行

通知方法：

前置通知(@Before)：logStart: 在目标方法（div）运行之前运行
后置通知(@After)：logEnd: 在目标方法（div）运行结束之后运行
返回通知(@AfterReturning)：logReturn: 在目标方法div正常返回之后运行
异常通知(@AfterThrowing)：logException: 在目标方法（div）出现异常以后运行
环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）

给切面类的目标方法标注何时何地运行（通知注解）

并且必须告诉Spring哪个类是切面类（给切面类上加一个注解：@Aspect）

package com.atguigu.aop;

import java.util.Arrays;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

/**
 * 切面类
 * 
 * @Aspect: 告诉Spring当前类是一个切面类
 * @author john
 *
 */
@Aspect
public class LogAspects {
	
	//抽取公共的切入点表达式
	//1.如果在本类引用:("pointCut()")
	//2.如果引用其他的切面类：必须用方法全名（"com.atguigu.aop.LogAspects.pointCut()"）
	//写法参照Spring官方文档
	@Pointcut("execution(public int com.atguigu.aop.MathCalculator.*(..))")
	public void pointCut() {}
	
	//@Before：在目标方法之前切入 ； 切入点表达式（指定在哪个方法切入）
	//使用目标方法全名
//	@Before("public int com.atguigu.aop.MathCalculator.div(int, int)")
	//任意方法，任意多参数
//	@Before("public int com.atguigu.aop.MathCalculator.*(..)")
	//抽取公共的切入点表达式
	@Before("pointCut()")
	public void logStart(JoinPoint joinPoint) {
		//获取的方法的方法名： joinPoint.getSignature().getName()
		//获取的方法的参数： joinPoint.getArgs()
		Object[] args = joinPoint.getArgs();
		System.out.println(""+joinPoint.getSignature().getName()+"运行。。。参数列表是：{"+Arrays.asList(args)+"}");
	}
	
	//@After: 在目标方法之后；切入无论方法正常结束或者异常结束都执行
//	@After("public int com.atguigu.aop.MathCalculator.*(..)")
	//抽取公共的切入点表达式
	@After("pointCut()")
	public void logEnd(JoinPoint joinPoint) {
		System.out.println(""+joinPoint.getSignature().getName()+"结束");
	}
	
	//JoinPoint一定要出现在参数表的第一位
	@AfterReturning(value="pointCut()",returning="result")
	public void logReturn(JoinPoint joinPoint,Object result){
		System.out.println(""+joinPoint.getSignature().getName()+"正常返回。。。@AfterReturning:运行结果：{"+result+"}");
	}
	
	@AfterThrowing(value="pointCut()",throwing="exception")
	public void logException(JoinPoint joinPoint,Exception exception){
		System.out.println(""+joinPoint.getSignature().getName()+"异常。。。异常信息：{"+exception+"}");
	}
}

配置类：将切面类和业务逻辑类（目标方法所在类）都加入到容器中

并且给配置类中加@EnableAspectJAutoProxy 【开启基于注解的aop模式】

package com.atguigu.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

import com.atguigu.aop.LogAspects;
import com.atguigu.aop.MathCalculator;

/**
 * AOP:【动态代理】
 * 		指在程序运行期间动态的将某段代码切入到指定方法指定位置进行运行的编程方式；
 * 1、导入aop模块；Spring AOP :(spring-aspects)
 * 2、定义一个业务逻辑类（MathCalculator）；在业务逻辑运行的时候将日志进行打印（方法之前、方法运行结束、方法出现异常）
 * 3、定义一个日志切面类（LogAspects）：切面类里面的方法需要动态感知MathCalculator.div运行到哪里然后执行；
 * 		通知方法：
 * 			前置通知(@Before)：logStart: 在目标方法（div）运行之前运行
 * 			后置通知(@After)：logEnd: 在目标方法（div）运行结束之后运行
 * 			返回通知(@AfterReturning)：logReturn: 在目标方法div正常返回之后运行
 * 			异常通知(@AfterThrowing)：logException: 在目标方法（div）出现异常以后运行
 * 			环绕通知(@Around)：动态代理，手动推进目标方法运行（joinPoint.procced()）
 * 4、给切面类的目标方法标注何时何地运行（通知注解）；并且必须告诉Spring哪个类是切面类（给切面类上加一个注解：@Aspect）
 * 5、将切面类和业务逻辑类（目标方法所在类）都加入到容器中；
 * 6、给配置类中加@EnableAspectJAutoProxy 【开启基于注解的aop模式】
 * 			在
 */
@EnableAspectJAutoProxy
@Configuration
public class MainConfigOfAOP {

	//业务逻辑类加入容器中
	@Bean
	public MathCalculator calculator() {
		return new MathCalculator();
	}
	
	//切面类加入到容器中
	@Bean
	public LogAspects logAspects() {
		return new LogAspects();
	}
	
}

测试类

package com.atguigu.test;

import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.atguigu.aop.MathCalculator;
import com.atguigu.config.MainConfigOfAOP;

import com.atguigu.dao.BookDao;
import com.atguigu.service.BookService;

public class IOCTest_AOP {
	
	@Test
	public void test01(){
		AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);
		
		//1、不要自己创建对象
//		MathCalculator mathCalculator = new MathCalculator();
//		mathCalculator.div(1, 1);
		MathCalculator mathCalculator = applicationContext.getBean(MathCalculator.class);
		
		
		System.out.println("-----------------------正常测试------------------------");
		//正常测试
		mathCalculator.div(1, 1);
		
		System.out.println("-----------------------异常测试------------------------");
		//异常测试
		mathCalculator.div(1, 0);
		
		applicationContext.close();
	}

}

写AOP主要把握三步：

1）、将业务逻辑组件和切面类都加入到容器中；告诉Spring哪个是切面类（@Aspect）
2)、在切面类上的每一个通知方法上标注通知注解，告诉Spring何时何地运行（切入点表达式）
3）、开启基于注解的aop模式： @EnableAspectJAutoProxy

你可能感兴趣的:(spring,springBoot,spring)

Spring Boot 集成 Redis 全解析翻晒时光 springboot spring boot redis
在当今快速发展的互联网应用开发中，性能和效率是至关重要的因素。Redis作为一款高性能的内存数据库，常被用于缓存、消息队列、分布式锁等场景，能够显著提升应用程序的响应速度和吞吐量。SpringBoot以其强大的自动配置和快速开发特性，成为众多Java开发者的首选框架。将SpringBoot与Redis集成，可以充分发挥两者的优势，构建出高效、稳定的应用系统。本文将详细介绍SpringBoot集成R
基于springbootBBS论坛系统的设计与实现四金学长计算机毕业设计参考案例 spring boot maven java BBS论坛系统
1.引言在当今的软件开发领域，企业级应用的开发和部署速度直接影响着业务的竞争力。SpringBoot以其轻量级、快速启动和强大的集成能力，成为构建现代企业级应用的首选框架。本文将带您深入了解SpringBoot框架的核心特性，并展示如何利用它构建一个高效、可扩展的系统。2.开发环境开发语言：Java框架：springbootJD版本：JDK1.8服务器：tomcat7数据库：mysql5.7（一定
SpringBoot为什么要禁止循环依赖? java1234_小锋 java java 开发语言
大家好，我是锋哥。今天分享关于【SpringBoot为什么要禁止循环依赖?】面试题。希望对大家有帮助；SpringBoot为什么要禁止循环依赖?1000道互联网大厂Java工程师精选面试题-Java资源分享网SpringBoot禁止循环依赖的原因与Spring框架本身的设计和依赖注入机制密切相关。以下是详细解释：1.依赖注入的基本原理在Spring框架中，依赖注入（DependencyInject
基于数据可视化SpringBoot+Vue+Uniapp的学生活动管理系统设计与实现（毕业设计实战项目+源码+部署） Java开源领先者 #Java网站项目 #微信小程序毕设 #Java精品毕设信息可视化 spring boot vue.js 毕业设计 java uni-app 学生活动管理
博主介绍CSDN毕设辅导第一人、靠谱第一人、全网粉丝50W+,csdn特邀作者、博客专家、腾讯云社区合作讲师、CSDN新星计划导师、Java领域优质创作者,博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和学生毕业项目实战,高校老师/讲师/同行前辈交流✌技术范围：SpringBoot、Vue、SSM、HLMT、Jsp、PHP、Nodejs、Python、爬虫、数据可
vue视频流播放,支持多种视频格式，如rmvb、mkv BigData-0 vue.js 前端 javascript
先将视频转码为tsffmpeg-iC:\test\3.rmvb-codec:copy-start_number0-hls_time10-hls_list_size0-fhlsC:\test\a\output.m3u8后端配置接口importorg.springframework.core.io.Resource;importorg.springframework.core.io.UrlResour
springboot第83集：理解SaaS多租户应用的架构和设计，设备介入，网关设备，安全，实时实现，序列化... 掘金-我是哪吒 spring boot 架构安全数据库后端
springboot第83集：理解SaaS多租户应用的架构和设计，设备介入，网关设备，安全，实时实现，序列化，数据交换，存储与查询，流处理，消息队列[什么是多租户]聊到PaaS,SaaS，就不得不谈到多租户。多租户指一套系统能够支撑多个租户。一个租户通常是具有相似访问模式和权限的一组用户，典型的租户是同一个组织或者公司的若干用户。要实现多租户，首先需要考虑的是数据层面的多租户。数据层的多租户模型对
聊一下分布式与微服务只因在人海中多看了你一眼分布式微服务 spring cloud
文章目录一、分布式二、微服务（SpringBoot）2.1自动配置与起步依赖自动配置起步依赖2.2启动流程2.3配置加载机制2.4集成SpringMVCSpringMVCRESTfulAPI2.5集成SpringDataJPA与Mybatis整合SpringDataJPAMybatis2.6安全与监控SpringSecuritySpringBootActuator三、微服务（SpringCloud
SpringCloud初体验1：父工程搭建 ljg963419 软件开发 intellij-idea maven java
1.IDEA新建工程，选Maven项目点【下一步】，根据项目命名name：mistycloudlocation：D:\develop\workspace_study\mistycloudGroupId：org.mistyArtifactId：mistycloudVersion：1.0-SNAPSHOT点【Finish】2.初始POM文件内容如下：4.0.0
搭建springcloud脚手架 zzyh123456 spring cloud spring 后端
搭建SpringCloud脚手架通常意味着创建一个包含多个SpringBoot项目（作为微服务）以及必要的SpringCloud组件（如服务注册与发现、配置中心、API网关等）的基础框架，以便快速启动和扩展微服务架构的应用。以下是一个简化的步骤，用于搭建SpringCloud脚手架：1.环境准备确保你的开发环境已经安装了JDK、Maven（或Gradle）、以及一个IDE（如IntelliJIDE
springcloud负载均衡原理 zzyh123456 spring cloud 负载均衡 java
SpringCloud负载均衡的原理主要涉及到客户端负载均衡的实现方式，特别是在微服务架构中如何均匀分配请求到多个服务实例上。以下是SpringCloud负载均衡的详细原理：1.负载均衡概述负载均衡（LoadBalancing）是在分布式系统中，将工作负载（Workload）平均分配给多个服务器或计算机资源，以提高系统的性能、可靠性和可扩展性。在SpringCloud中，负载均衡主要用于微服务架构
Spring集成Redis｜通用Redis工具类里昂(Leon) 工具类目 spring redis spring boot
一、基础使用概述在SpringBoot中一般使用RedisTemplate提供的方法来操作Redis。那么使用SpringBoot整合Redis需要那些步骤呢。1、JedisPoolConfig(这个是配置连接池)2、RedisConnectionFactory这个是配置连接信息，这里的RedisConnectionFactory是一个接口，我们需要使用它的实现类。3、RedisTemplate基
深入解析 GZIP 压缩传输：优化网络性能的利器码农阿豪@新空间代码工作室好“物”分享网络
个人名片作者简介：java领域优质创作者个人主页：码农阿豪工作室：新空间代码工作室（提供各种软件服务）个人邮箱：[[email protected]]个人微信：15279484656个人导航网站：www.forff.top座右铭：总有人要赢。为什么不能是我呢？专栏导航：码农阿豪系列专栏导航面试专栏：收集了java相关高频面试题，面试实战总结️Spring5系列专栏：整理了Spring5重要知识点与
Spring 框架基础：IOC 与 AOP 原理剖析及面试要点翻晒时光 Java春招面试指南 spring 面试 java
在上一篇中，我们深入探讨了Java反射机制，了解了它在运行时动态操作类和对象的强大能力。而今天，我们将进入Spring框架的世界。Spring框架作为Java企业级开发中最流行的框架之一，极大地简化了企业级应用的开发过程。对于春招面试而言，Spring框架的基础知识是重点考察内容，其中控制反转（IOC）和面向切面编程（AOP）是Spring框架的核心思想，下面我们来详细了解。一、控制反转（IOC）
使用 Spring AI 调用本地模型实现 drebander AI 编程 spring java springAI
在本篇博客中，我们将学习如何使用SpringAI框架调用本地的PyTorch模型，并通过SpringBoot提供一个预测接口。SpringAI是一个用于将人工智能应用集成到Spring生态系统中的框架，它支持多种AI模型和数据源的集成，帮助开发者将AI模型无缝地集成到Java应用中。1.准备PyTorch模型首先，我们需要训练并保存一个PyTorch模型。这里我们使用一个简单的神经网络模型作为示例
SpringBoot使用Kafka如何保证消息不丢失小信丶消息队列技术栈 spring boot kafka 后端
概述在SpringBoot中使用Kafka时，要确保消息不丢失，主要涉及到生产者（Producer）、消费者（Consumer）以及KafkaBroker的配置和设计。1.SpringBoot与Kafka配置SpringBoot中使用Kafka时，可以通过spring-kafka来简化配置和操作。以下是如何保证消息不丢1.1Producer配置Kafka生产者是消息的发送方，确保消息的可靠性和不丢
基于数据可视化+SpringBoot+Vue的医院综合管理平台设计和实现(源码+论文+部署讲解等) java李杨勇 Java精品毕设实战案例 Java毕业设计实战案例信息可视化 spring boot vue.js 医院综合管理平台 Java毕业设计
博主介绍：✌全网粉丝50W+,csdn特邀作者、博客专家、CSDN新星计划导师、Java领域优质创作者,博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和学生毕业项目实战,高校老师/讲师/同行前辈交流✌技术范围：SpringBoot、Vue、SSM、HLMT、Jsp、PHP、Nodejs、Python、爬虫、数据可视化、小程序、安卓app、大数据、物联网、机器学习等
在JPA中，使用实体图查询具有自定义中间表的多对多实体 ForteScarlet 水文罢了 java hibernate spring spring boot jpa
大家好哇！不知道大家在使用JPA的时候有没有试用过实体图(EntityGraph)进行查询呢？它的功能很强大，比如可以用来规避大家经常遇到的n+1的问题。那么你了不了解如何在"自定义中间表"的情况下去使用实体图查询呢？如果不太了解，那么就来跟着我看一下吧！为了方便演示，后续的项目环境默认视为在spring-boot-starter-data-jpa中喔~实体定义首先，我们先来看看普通的多对多实体是
基于微信小程序的任务打卡管理系统小程序设计与实现(源码+lw+部署+讲解) 计算机YiDian 计算机毕设实战案例微信小程序毕设实战案例微信小程序小程序
文章目录1.前言2.详细视频演示3具体实现截图3.1小程序端部分效果3.2后台管理端部分效果4.技术可行性分析5.技术简介5.1后端框架SpringBoot5.2微信小程序5.3系统开发平台6.业务流程分析7.代码参考8.数据库参考9.为什么选择我们10.源码及文档获取1.前言博主介绍：✌CSDN特邀作者、全栈领域优质创作者、10年IT从业经验、码云/掘金/知乎/B站/华为云/阿里云等平台优质作者
Spring在业务中常见的使用方式孜泽 spring java spring
通过IOC实现策略模式很多时候，我们需要对不同的场景进行不同的业务逻辑处理，举个例子，譬如不同的场景需要不同支付方式，普通的逻辑是使用if-else，如下所示：//if-else实现publicvoiduse(Scenescene){if(scene==TENCENT){doWeiXinPay();}elseif(scene==ALIBABA){doAlipay();}else{doDothing
SpringBoot项目修改内置tomcat版本 egegerhn java java 后端
覆盖掉tomcat版本8.5.51org.apache.tomcat.embedtomcat-embed-core${tomcat.version}org.apache.tomcattomcat-juli${tomcat.version}忽略掉spring-boot-starter-web里的tomcatorg.springframework.bootspring-boot-starter-web
【Springer斯普林格出版，Ei稳定，往届快速见刊检索】第四届电子信息工程、大数据与计算机技术国际学术会议（ EIBDCT 2025）艾思科蓝 AiScholar 学术会议计算机科学电子信息科学与技术大数据信息可视化可信计算技术深度学习人工智能自然语言处理信息与通信
第四届电子信息工程、大数据与计算机技术国际学术会议（EIBDCT2025）20254thInternationalConferenceonElectronicInformationEngineering,BigDataandComputerTechnology中国-青岛|2025年2月21-23日|www.eibdct.net组织单位长春电子科技大学、加拿大魁北克大学、美国新泽西理工学院、美国欧道
Servlet 和 Spring MVC：区别与联系 qq_44199605 servlet spring mvc
前言在JavaWeb开发中，Servlet和SpringMVC是两个重要的技术。Servlet是JavaWeb的基础组件，而SpringMVC是一个高级Web框架，建立在Servlet的基础之上，提供了强大的功能和易用性。这篇文章将从定义、原理、功能对比、应用场景等多个方面，详细介绍Servlet和SpringMVC，并解析它们的区别与联系。一、什么是Servlet1.定义Servlet是Java
【分布式WebSocket - 3】SpringBoot集成STOMP协议完成私聊、群聊叁滴水 websocket websocket stomp 新星计划
文章目录一、为什么需要STOMP?二、STOMP详解三、SpringBoot集成STOMP代码示例3.1、功能示例3.2、架构图3.3、服务端代码3.4、h5代码一、为什么需要STOMP?WebSocket协议是一种相当低级的协议。它定义了如何将字节流转换为帧。帧可以包含文本或二进制消息。由于消息本身不提供有关如何路由或处理它的任何其他信息，因此很难在不编写其他代码的情况下实现更复杂的应用程序。幸
Alibaba Spring Cloud 三 Seata 的三大核心组件：TC，TM，RM 空灵宫（Ethereal Palace） Alibaba Spring Cloud spring cloud 架构 spring
Seata的架构由三大核心组件构成：TransactionCoordinator（TC）、TransactionManager（TM）和ResourceManager（RM）。它们协同工作，用于管理分布式事务的生命周期，确保全局数据一致性。以下是对这三个组件的详细解析及其作用：1.Seata的三大核心组件1.1TransactionCoordinator（TC）事务协调者作用：负责管理全局事务的生
【Bug合集】——Java大小写引起传参失败，获取值为null的解决方案三三是该溜子 java 开发语言 Springboot
阿华代码，不是逆风，就是我疯你们的点赞收藏是我前进最大的动力！！希望本文内容能够帮助到你！！目录一：本文面向的人群二：错误场景引入三：正确场景引入四：问题解决五：解决方法1：public修饰2：使用@JsonProperty注解一：本文面向的人群本文主要针对类中成员变量命名问题引起传送json字符串，但是变量为null的情况做出解释。其中涉及到@Data注解（Spring自动生成的get和set方
Spring Security 入门后端java
SpringSecurity是Spring框架中一个功能强大且灵活的安全模块。它为应用程序提供了强大的认证和授权功能，同时支持防止常见的安全攻击（如CSRF和会话固定攻击）。在开发Web应用程序时，理解和配置SpringSecurity是保障系统安全的关键。一、SpringSecurity的核心概念认证（Authentication）认证是指验证用户的身份，即确认用户是谁。SpringSecuri
logback+kafka+ELK实现日志记录（操作）酷酷的码农小哥 java kafka spring boot spring
logback+kafka+ELK实现日志记录前言环境准备配置Logbackpom文件改造新增logback-spring.xmlboot配置文件一下怎么去下载安装我就不多说了，直接上代码。日志平台业务思路用户请求进入后台根据搜索的参数去查询内容返回所有信息,返回json数据，当用户查看详情后根据查询到的内容里面的traceId去es里查询和traceId相等的所有日志信息最后返回给前端业务流程[
第二章 SpringBoot快速开发框架 - Mysql数据源配置暗夜91 Spring Boot快速开发基础框架 mysql spring boot java
作者简介：作者：暗夜91个人主页：暗夜91的主页如果感觉文章写的还有点帮助，请帮忙点个关注，我会持续输出高质量技术博文。专栏文章:1、集成Swagger，生成API文档2、Mysql数据源配置3、集成Redis4、SpringSecurity+JWT实现登录权限认证5、跨域配置专栏源码：针对该专栏功能，对源码进行整理，可以直接下载运行。源码下载请移步：SpringBoot快速开发框架一、数据源配置
easyexcel读取写入excel easyexceldemo JavaNice哥 java excel
1.新建springboot项目2.添加pom依赖excelexcelspringboot例子org.springframework.bootspring-boot-starter-parent2.2.1.RELEASEUTF-8UTF-81.81.81.82.3.0org.springframework.bootspring-boot-starter-weborg.springframework
【微服务】SpringBoot 整合ELK使用详解逆风飞翔的小叔精通springboot微服务 java使用elk springboot整合elk elk搭建到使用 elk使用详解 elk搭建
目录一、前言二、为什么需要ELK三、ELK介绍3.1什么是elk3.2elk工作原理四、ELK搭建4.1搭建es环境4.1.1获取es镜像4.1.2启动es容器4.1.3配置es参数4.1.4重启es容器并访问4.2搭建kibana4.2.1拉取kibana镜像4.2.2启动kibana容器4.2.3修改配置文件4.2.4重启容器并访问4.3搭建logstash4.3.1下载安装包4.3.2解压安
knob UI插件使用换个号韩国红果果 JavaScript jsonp knob
图形是用canvas绘制的 js代码 var paras = { max:800, min:100, skin:'tron',//button type thickness:.3,//button width width:'200',//define canvas width.,canvas height displayInput:'tr
Android+Jquery Mobile学习系列(5)-SQLite数据库白糖_ JQuery Mobile
目录导航 SQLite是轻量级的、嵌入式的、关系型数据库，目前已经在iPhone、Android等手机系统中使用,SQLite可移植性好，很容易使用，很小，高效而且可靠。因为Android已经集成了SQLite，所以开发人员无需引入任何JAR包，而且Android也针对SQLite封装了专属的API，调用起来非常快捷方便。我也是第一次接触S
impala-2.1.2-CDH5.3.2 dayutianfei impala
最近在整理impala编译的东西，简单记录几个要点：根据官网的信息（https://github.com/cloudera/Impala/wiki/How-to-build-Impala）： 1. 首次编译impala，推荐使用命令： ${IMPALA_HOME}/buildall.sh -skiptests -build_shared_libs -format 2.仅编译BE ${I
求二进制数中1的个数周凡杨 java 算法二进制
解法一：对于一个正整数如果是偶数，该数的二进制数的最后一位是 0 ，反之若是奇数，则该数的二进制数的最后一位是 1 。因此，可以考虑利用位移、判断奇偶来实现。 public int bitCount(int x){ int count = 0; while(x!=0){ if(x%2!=0){ /
spring中hibernate及事务配置 g21121 Hibernate
hibernate的sessionFactory配置：  <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <
log4j.properties 使用 510888780 log4j
log4j.properties 使用一.参数意义说明输出级别的种类 ERROR、WARN、INFO、DEBUG ERROR 为严重错误主要是程序的错误 WARN 为一般警告，比如session丢失 INFO 为一般要显示的信息，比如登录登出 DEBUG 为程序的调试信息配置日志信息输出目的地 log4j.appender.appenderName = fully.qua
Spring mvc-jfreeChart柱图（2）布衣凌宇 jfreechart
上一篇中生成的图是静态的，这篇将按条件进行搜索，并统计成图表，左面为统计图，右面显示搜索出的结果。第一步：导包第二步；配置web.xml(上一篇有代码) 建BarRenderer类用于柱子颜色 import java.awt.Color; import java.awt.Paint; import org.jfree.chart.renderer.category.BarR
我的spring学习笔记14-容器扩展点之PropertyPlaceholderConfigurer aijuans Spring3
PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。 PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java
maven 之 cobertura 简单使用 antlove maven test unit cobertura report
1. 创建一个maven项目 2. 创建com.CoberturaStart.java package com; public class CoberturaStart { public void helloEveryone(){ System.out.println("=================================================
程序的执行顺序百合不是茶 JAVA执行顺序
刚在看java核心技术时发现对java的执行顺序不是很明白了,百度一下也没有找到适合自己的资料,所以就简单的回顾一下吧代码如下; 经典的程序执行面试题 //关于程序执行的顺序 //例如： //定义一个基类 public class A(){ public A(
设置session失效的几种方法 bijian1013 web.xml session失效监听器
在系统登录后，都会设置一个当前session失效的时间，以确保在用户长时间不与服务器交互，自动退出登录，销毁session。具体设置很简单，方法有三种：（1）在主页面或者公共页面中加入：session.setMaxInactiveInterval(900);参数900单位是秒，即在没有活动15分钟后，session将失效。这里要注意这个session设置的时间是根据服务器来计算的，而不是客户端。所
java jvm常用命令工具 bijian1013 java jvm
一.概述程序运行中经常会遇到各种问题，定位问题时通常需要综合各种信息，如系统日志、堆dump文件、线程dump文件、GC日志等。通过虚拟机监控和诊断工具可以帮忙我们快速获取、分析需要的数据，进而提高问题解决速度。本文将介绍虚拟机常用监控和问题诊断命令工具的使用方法，主要包含以下工具: &nbs
【Spring框架一】Spring常用注解之Autowired和Resource注解 bit1129 Spring常用注解
Spring自从2.0引入注解的方式取代XML配置的方式来做IOC之后，对Spring一些常用注解的含义行为一直处于比较模糊的状态，写几篇总结下Spring常用的注解。本篇包含的注解有如下几个： Autowired Resource Component Service Controller Transactional 根据它们的功能、目的，可以分为三组，Autow
mysql 操作遇到safe update mode问题 bitray update
我并不知道出现这个问题的实际原理,只是通过其他朋友的博客,文章得知的一个解决方案,目前先记录一个解决方法,未来要是真了解以后,还会继续补全. 在mysql5中有一个safe update mode,这个模式让sql操作更加安全,据说要求有where条件,防止全表更新操作.如果必须要进行全表操作,我们可以执行 SET
nginx_perl试用 ronin47 nginx_perl试用
因为空闲时间比较多，所以在CPAN上乱翻，看到了nginx_perl这个项目(原名Nginx::Engine)，现在托管在github.com上。地址见：https://github.com/zzzcpan/nginx-perl 这个模块的目的，是在nginx内置官方perl模块的基础上，实现一系列异步非阻塞的api。用connector/writer/reader完成类似proxy的功能（这里
java-63-在字符串中删除特定的字符 bylijinnan java
public class DeleteSpecificChars { /** * Q 63 在字符串中删除特定的字符 * 输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。 * 例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.” */ public static voi
EffectiveJava--创建和销毁对象 ccii 创建和销毁对象
本章内容： 1. 考虑用静态工厂方法代替构造器 2. 遇到多个构造器参数时要考虑用构建器（Builder模式） 3. 用私有构造器或者枚举类型强化Singleton属性 4. 通过私有构造器强化不可实例化的能力 5. 避免创建不必要的对象 6. 消除过期的对象引用 7. 避免使用终结方法 1. 考虑用静态工厂方法代替构造器类可以通过
[宇宙时代]四边形理论与光速飞行 comsci
从四边形理论来推论为什么光子飞船必须获得星光信号才能够进行光速飞行？一组星体组成星座向空间辐射一组由复杂星光信号组成的辐射频带，按照四边形-频率假说一组频率就代表一个时空的入口那么这种由星光信号组成的辐射频带就代表由这些星体所控制的时空通道，该时空通道在三维空间的投影是一
ubuntu server下python脚本迁移数据 cywhoyi python Kettle pymysql cx_Oracle ubuntu server
因为是在Ubuntu下，所以安装python、pip、pymysql等都极其方便，sudo apt-get install pymysql，但是在安装cx_Oracle（连接oracle的模块）出现许多问题，查阅相关资料，发现这边文章能够帮我解决，希望大家少走点弯路。http://www.tbdazhe.com/archives/602 1.安装python 2.安装pip、pymysql
Ajax正确但是请求不到值解决方案 dashuaifu Ajax async
Ajax正确但是请求不到值解决方案解决方案：1 . async: false , 2. 设置延时执行js里的ajax或者延时后台java方法！！！！！！！例如： $.ajax({ &
windows安装配置php+memcached dcj3sjt126com PHP Install memcache
Windows下Memcached的安装配置方法 1、将第一个包解压放某个盘下面，比如在c:\memcached。 2、在终端（也即cmd命令界面）下输入 'c:\memcached\memcached.exe -d install' 安装。 3、再输入： 'c:\memcached\memcached.exe -d start' 启动。（需要注意的: 以后memcached将作为windo
iOS开发学习路径的一些建议 dcj3sjt126com ios
iOS论坛里有朋友要求回答帖子，帖子的标题是：想学IOS开发高阶一点的东西，从何开始，然后我吧啦吧啦回答写了很多。既然敲了那么多字，我就把我写的回复也贴到博客里来分享，希望能对大家有帮助。欢迎大家也到帖子里讨论和分享，地址：http://bbs.csdn.net/topics/390920759 下面是我回复的内容：结合自己情况聊下iOS学习建议，
Javascript闭包概念 fanfanlovey JavaScript 闭包
1.参考资料 http://www.jb51.net/article/24101.htm http://blog.csdn.net/yn49782026/article/details/8549462 2.内容概述要理解闭包，首先需要理解变量作用域问题内部函数可以饮用外面全局变量 var n=999; 　　functio
yum安装mysql5.6 haisheng mysql
1、安装http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm 2、yum install mysql 3、yum install mysql-server 4、vi /etc/my.cnf 添加character_set_server=utf8
po/bo/vo/dao/pojo的详介 IT_zhlp80 java BO VO DAO POJO po
JAVA几种对象的解释 PO:persistant object持久对象,可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作. VO:value object值对象。通常用于业务层之间的数据传递，和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可
java设计模式 kerryg java 设计模式
设计模式的分类：一、设计模式总体分为三大类： 1、创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。 2、结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。 3、行为型模式（11种）：策略模式，模版方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者
[1]CXF3.1整合Spring开发webservice——helloworld篇木头.java spring webservice CXF
Spring 版本3.2.10 CXF 版本3.1.1 项目采用MAVEN组织依赖jar 我这里是有parent的pom，为了简洁明了，我直接把所有的依赖都列一起了，所以都没version，反正上面已经写了版本 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="ht
Google 工程师亲授：菜鸟开发者一定要投资的十大目标 qindongliang1922 工作感悟人生
身为软件开发者，有什么是一定得投资的？ Google 软件工程师 Emanuel Saringan 整理了十项他认为必要的投资，第一项就是身体健康，英文与数学也都是必备能力吗？来看看他怎么说。（以下文字以作者第一人称撰写））你的健康无疑地，软件开发者是世界上最久坐不动的职业之一。每天连坐八到十六小时，休息时间只有一点点，绝对会让你的鲔鱼肚肆无忌惮的生长。肥胖容易扩大罹患其他疾病的风险，
linux打开最大文件数量1,048,576 tianzhihehe c linux
File descriptors are represented by the C int type. Not using a special type is often considered odd, but is, historically, the Unix way. Each Linux process has a maximum number of files th
java语言中PO、VO、DAO、BO、POJO几种对象的解释衞酆夼 java VO BO POJO po
PO:persistant object持久对象最形象的理解就是一个PO就是数据库中的一条记录。好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作。 BO:business object业务对象封装业务逻辑的java对象