Spring Framework基础

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
       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">  

</beans>

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
       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">  
  
    <!--  
        1. 使用无参构造函数实例化组件  
            等效伪代码为：  
                UserMapper userMapper1 = UserMapper();  
            id为组件标识，要求唯一  
            class为组价的全限定符  
    -->  
    <bean id="userMapper1" class="indi.h13.mappers.UserMapper"/>  
  
    <!--  
        一个类可以被实例化为多个不同id的组件  
    -->  
    <bean id="userMapper2" class="indi.h13.mappers.UserMapper"/>  
  
    <!--  
        2. 使用静态工厂类(静态方法)实例化组件  
            等效伪代码为：  
                UserService userService1 = UserService.createUserService();  
            id为组件标识，要求唯一  
            class为组价的全限定符  
            factory-method为静态实例化方法  
    -->  
    <bean id="userService1" class="indi.h13.services.UserService" factory-method="createUserService"/>  
  
    <!--  
        3. 基于实例工厂方法(非静态方法)实例化  
            需要先创建一个能生成该类的对象，随后用该对象生成目标对象。            等效伪代码为：  
                ServiceLocator serviceLocator = new ServiceLocator();                UserService userService2 = serviceLocator.createUserService();  
            id为Bean标识，要求唯一  
            factory-bean为生成该方法的Bean的id  
            factory-method为实例化该类的方法  
    -->  
    <bean id="serviceLocator" class="indi.h13.ServiceLocator" />  
    <bean id="userService2" factory-bean="serviceLocator" factory-method="createUserService" />  
  
</beans>

package indi.h13.controllers;  
import indi.h13.services.UserService;  

@Controller
public class UserController {  
    private UserService service;  
    public UserController() {}  
}

package indi.h13.mappers;  

@Repository(value="userMapper01")
public class UserMapper {  
	public UserMapper(String dbUserName, String dbPassword) {  
	    System.out.println("Created a UserMapper using a constructor with dbUserName " + dbUserName + ", dbPassword " + dbPassword);  
	}
}

package indi.h13.services;  
import indi.h13.mappers.UserMapper; 

@Service
public class UserService {  
	private UserMapper mapper;
    public UserService(UserMapper mapper){ 
	    this.mapper = mapper;
    }  
}

<?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"  
       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">  
  
    <!-- 以下Demo为独立Demo，根据需求选用一个即可 -->  
    <!-- Demo 1: 扫描包indi.h13下所有关于组件的注解 -->  
    <context:component-scan base-package="indi.h13"/>  
  
    <!-- Demo 2: 扫描包indi.h13下除了Service以外的注解 -->  
    <context:component-scan base-package="indi.h13">  
        <!-- 屏蔽Service注解 -->  
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>  
    </context:component-scan>  
  
    <!-- Demo 3: 扫描包indi.h13下所有Controller注解(只要Controller) -->  
    <!-- 注意多了个 use-default-filters 属性!!! -->  
    <context:component-scan base-package="indi.h13" use-default-filters="false">  
        <!-- 只扫描(保留)Controller注解 -->  
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>  
    </context:component-scan>  
  
</beans>

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
       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">  
  
    <bean id="userMapper" class="indi.h13.mappers.UserMapper">  
        <!--  
            构造函数注入，方式一：直接顺序填写参数  
            value为直接引用值。不管实际使用的是什么类型，在xml中均要配置为字符串。  
            ref为引用其他的spring bean。  
        -->  
        <constructor-arg value="root"/> <!-- dbUserName = "root" -->  
        <constructor-arg value="pswd"/> <!-- dbPassword = "pswd" -->  
    </bean>  
  
    <bean id="userService" class="indi.h13.services.UserService">  
        <!--  
            构造函数注入，方式二[推荐]：指定参数名称并给定值  
            value为直接引用值。不管实际使用的是什么类型，在xml中均要配置为字符串。  
            ref为引用其他的spring bean。  
        -->  
        <constructor-arg name="mapper" ref="userMapper"/>  
    </bean>  

    <bean id="userMapper2" class="indi.h13.mappers.UserMapper">  
        <!--  
            构造函数注入，方式三：指定参数角标并赋值
        -->  
        <constructor-arg index="0" value="root"/> <!-- dbUserName = "root" -->  
        <constructor-arg index="1" value="pswd"/> <!-- dbPassword = "pswd" --> 
    </bean>  

    <bean id="userController" class="indi.h13.controllers.UserController">  
        <!--  
	        setter接口注入[重要]：使用setter接口注入。此时使用property标签  
            name为setter实际操作的私有变量的名称  
        -->  
        <property name="service" ref="userService"/>  
    </bean>
</beans>

package indi.h13.controllers;  
import indi.h13.services.UserService;  
import lombok.Setter;  

@Setter
public class UserController {  
    private UserService service;  
    public UserController() {}  
}

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
       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">  

	<context:property-placeholder location="classpath:jdbc.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">  
	    <property name="url" value="{jdbc.url}" />
	    <property name="driverClassName" value="{jdbc.driver}" />
	    <property name="username" value="{jdbc.username}" />
	    <property name="password" value="{jdbc.password}" />
    </bean>  
    
</beans>

// 配置包扫描注解，`value = ` 可以省略
@ComponentScan(value = { "indi.h13.package1", "indi.h13.package2", ...})
// 配置配置文件名注解，`value = ` 可以省略
@PropertySource(value = "classpath:jdbc.properties")
@Configuration
public class JavaConfiguration {
}

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
       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">  

    <context:component-scan base-package="indi.h13.package1"/>  
    <context:component-scan base-package="indi.h13.package2"/>  
	<context:property-placeholder location="classpath:jdbc.properties"/>
	
</beans>

// 配置包扫描注解，`value = ` 可以省略
@ComponentScan(value = { "indi.h13.package1", "indi.h13.package2", ...})
// 配置配置文件名注解，`value = ` 可以省略
@PropertySource(value = "classpath:jdbc.properties")
@Configuration
public class JavaConfiguration {

	@Value("{jdbc.url}")
	private String url;
	@Value("{jdbc.driver}")
	private String driver;
	@Value("{jdbc.username}")
	private String username;
	@Value("{jdbc.password}")
	private String password;
	
	@Bean
	public DruidDataSource dataSource() {
		DruidDataSource dataSource = new DruidDataSource();
		dataSource.setUrl(this.url);
		dataSource.setDriverClassName(this.driver);
		dataSource.setUsername(this.username);
		dataSource.setPassword(this.password);
		return dataSource;
	}
}

@ComponentScan(value = { "indi.h13.package1", "indi.h13.package2", ...})
@PropertySource(value = "classpath:jdbc.properties")
@Configuration
public class JavaConfiguration1 {
}

@ComponentScan(value = { "indi.h13.package3", "indi.h13.package4", ...})
@PropertySource(value = "classpath:jdbc.properties")
@Configuration
public class JavaConfiguration2 {
}

@Import(JavaConfiguration2.class)
@ComponentScan(value = { "indi.h13.package1", "indi.h13.package2", ...})
@PropertySource(value = "classpath:jdbc.properties")
@Configuration
public class JavaConfiguration1 {
}

// 1. [重要]直接指定类路径下的xml文件名实例化
ApplicationContext context = new ClassPathXmlApplicationContext("spring-01.xml");

// 2. [了解]先创建容器，随后指定配置文件并刷新
// 在Spring框架中使用的是本方法
ApplicationContext context = new ClassPathXmlApplicationContext();
context.setConfigLocations("spring-01.xml");
context.refresh();

// 1. [重要]使用配置类实例化容器
ApplicationContext context = new AnnotationConfigApplicationContext(JavaConfiguration.class);

// 2. [了解]先创建容器，随后指定配置类并刷新
ApplicationContext context = new AnnotationConfigApplicationContext();
context.register(JavaConfiguration.class);
context.refresh();

// 方式1[不推荐]：使用 `beanId` 获取，返回值类型为Object，需要使用强制类型转换操作对象。  
Object userMapperBean = context.getBean("userMapper");  
UserMapper userMapper = (UserMapper)userMapperBean;  
  
// 方式2[推荐]：使用 `beanId` 获取，同时指定类型  
// 此时不需要强转  
userMapper = context.getBean("userMapper", UserMapper.class);  
  
// 方式3：只使用类型获取，此时注意：  
// 1. 此方法只支持单例，即同一个类型在容器中只有一个Bean。否则运行时出错(NoUniqueBeanDefinitionException)  
// 2. 当使用父类或接口作为类型去获取时，也可以正常获取(只要 bean instanceof A.class == true即可，且整个项目中该父类只有一个实例)  
userMapper = context.getBean(UserMapper.class);

@Component
@Aspect
public class LogAdvance {
	@Before("execution(* indi.h13.ssserver.service.impl.*.*(..))")
	public void before(JoinPoint joinPoint) {
		// 1. 获取所属类的简称
		System.out.println("Class name: " + joinPoint.getTarget().getClass().getSimpleName());
		
		// 2. 获取所属类的全称
		System.out.println("Class name: " + joinPoint.getTarget().getClass().getName());

		// 3. 获取方法名
		System.out.println("Function name: " + joinPoint.getSignature().getName());

		// 4. 获取参数
		Object args[] = joinPoint.getArgs();

		// 5. 获取访问修饰符
		int modifiers = joinPoint.getSignature().getModifiers();
		System.out.println("Function modifiers: " + Modifier.toString(modifiers));
	}
}

@Component
@Aspect
public class LogAdvance {
	@AfterReturning(
		value = "execution(* indi.h13.ssserver.service.impl.*.*(..))",
		returning = result
	)
	public void afterReturning(Object result) {
		// ...
	}
}

@Component
@Aspect
public class LogAdvance {
	@AfterThrowing(
		value = "execution(* indi.h13.ssserver.service.impl.*.*(..))",
		throwing = throwable
	)
	public void afterThrowing(Throwable throwable) {
		System.out.println("@AfterThrowing ...");
	}
}