学习Spring day2

1.增强处理类型及特点

在Spring中，增强处理主要是通过AOP（面向切面编程）实现的。下面是Spring中常见的增强处理类型及其特点以及示例代码：

1. 前置增强（Before advice）：
   - 在目标方法执行之前执行的增强处理。
   - 可以用于验证参数、权限检查等操作。

```java
@Component
@Aspect
public class BeforeAdviceAspect {
    
    @Before("execution(* com.example.service.UserService.addUser(..))")
    public void beforeAddUser(JoinPoint joinPoint) {
        System.out.println("Before adding user...");
        // 执行前置增强的逻辑
    }
}
```

2. 后置增强（After returning advice）：
   - 在目标方法正常返回后执行的增强处理。
   - 可以用于记录日志、清理资源等操作。

```java
@Component
@Aspect
public class AfterReturningAdviceAspect {
    
    @AfterReturning(pointcut = "execution(* com.example.service.UserService.getUser(..))", returning = "user")
    public void afterReturningGetUser(JoinPoint joinPoint, User user) {
        System.out.println("After getting user...");
        // 执行后置增强的逻辑
    }
}
```

3. 异常增强（After throwing advice）：
   - 在目标方法抛出异常后执行的增强处理。
   - 可以用于异常处理、日志记录等操作。

```java
@Component
@Aspect
public class AfterThrowingAdviceAspect {
    
    @AfterThrowing(pointcut = "execution(* com.example.service.UserService.deleteUser(..))", throwing = "ex")
    public void afterThrowingDeleteUser(JoinPoint joinPoint, Exception ex) {
        System.out.println("After throwing exception when deleting user...");
        // 执行异常增强的逻辑
    }
}
```

4. 最终增强（After advice）：
   - 在目标方法执行完毕后执行的增强处理，无论是否发生异常。
   - 可以用于资源释放、事务提交等操作。

```java
@Component
@Aspect
public class AfterAdviceAspect {
    
    @After("execution(* com.example.service.UserService.updateUser(..))")
    public void afterUpdateUser(JoinPoint joinPoint) {
        System.out.println("After updating user...");
        // 执行最终增强的逻辑
    }
}
```

5. 环绕增强（Around advice）：
   - 在目标方法执行前后都可以执行的增强处理。
   - 可以用于在目标方法执行前后进行一系列的操作，如性能监控、缓存等。

```java
@Component
@Aspect
public class AroundAdviceAspect {
    
    @Around("execution(* com.example.service.UserService.getAllUsers(..))")
    public Object aroundGetAllUsers(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("Before getting all users...");
        // 执行前置增强的逻辑
        
        Object result = proceedingJoinPoint.proceed();
        
        System.out.println("After getting all users...");
        // 执行后置增强的逻辑
        
        return result;
    }
}
```

以上是Spring中常见的增强处理类型及其特点的示例代码。在实际应用中，可以根据具体需求选择合适的增强处理类型，并编写相应的增强处理逻辑。

2.构造注入

在Spring中，构造注入是一种通过构造函数来注入依赖的方式。通过构造注入，可以将依赖的对象作为参数传递给目标对象的构造函数，从而实现依赖的注入。

下面是使用构造注入的示例代码：

1. 定义依赖的类：

```java
public class Dependency {
    private String name;
    
    public Dependency(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
}
```

2. 定义目标类，并在构造函数中接收依赖对象：

```java
public class Target {
    private Dependency dependency;
    
    public Target(Dependency dependency) {
        this.dependency = dependency;
    }
    
    public void doSomething() {
        System.out.println("Dependency name: " + dependency.getName());
    }
}
```

3. 在Spring配置文件中配置目标类和依赖类的bean，并使用构造注入：

```xml
<bean id="dependency" class="com.example.Dependency">
    <constructor-arg value="DependencyName" />
</bean>

<bean id="target" class="com.example.Target">
    <constructor-arg ref="dependency" />
</bean>
```

在上述示例中，依赖类`Dependency`的bean被配置为id为`dependency`的bean，并通过`constructor-arg`元素指定了构造函数的参数值。目标类`Target`的bean被配置为id为`target`的bean，并通过`constructor-arg`元素指定了构造函数的参数引用。

通过以上配置，当Spring容器初始化时，会自动创建`dependency`和`target`的bean，并将`dependency`对象作为参数传递给`target`对象的构造函数，从而实现了构造注入。

在实际应用中，可以根据具体的需求和情况，使用构造注入来实现依赖的注入。构造注入可以保证依赖的完整性和不可变性，同时也提供了更好的可测试性和可维护性。

3.p命名空间注入

在Spring中，可以使用`p`命名空间来简化配置文件中的属性注入。通过使用`p`命名空间，可以直接在配置文件中使用属性名来指定属性值，而不需要使用`<property>`元素和`name`属性。

下面是使用`p`命名空间进行属性注入的示例代码：

1. 定义一个Java类：

```java
public class Person {
    private String name;
    private int age;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}
```

2. 在Spring配置文件中使用`p`命名空间进行属性注入：

```xml
<bean id="person" class="com.example.Person" p:name="John" p:age="30" />
```

在上述示例中，通过`p:name`和`p:age`来指定了`Person`类的`name`和`age`属性的值。这样，当Spring容器初始化时，会自动创建`person`的bean，并将指定的属性值注入到`Person`对象中。

3. 使用注入的对象：

```java
public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = (Person) context.getBean("person");
        person.displayInfo();
    }
}
```

在以上示例中，通过`ApplicationContext`来加载配置文件，并使用`getBean`方法获取`person`的bean对象。然后调用`displayInfo`方法来显示注入的属性值。

使用`p`命名空间注入属性可以简化配置文件的编写，提高代码的可读性和可维护性。但需要注意的是，使用`p`命名空间时，属性的setter方法必须按照规范命名，例如`setName`、`setAge`等，否则注入会失败。

4.不同数据类型的注入

在Spring中，可以使用不同的方式来注入Map、List、Set和Properties数据类型的属性。

1. Map注入：可以使用`map`元素来注入Map类型的属性。例如：

```xml
<bean id="person" class="com.example.Person">
    <property name="scores">
        <map>
            <entry key="Math" value="90" />
            <entry key="English" value="85" />
        </map>
    </property>
</bean>
```

在上述示例中，使用`map`元素来注入`scores`属性的Map。每个`entry`元素表示一个键值对，使用`key`属性来指定键，使用`value`属性来指定值。

2. List注入：可以使用`list`元素来注入List类型的属性。例如：

```xml
<bean id="person" class="com.example.Person">
    <property name="hobbies">
        <list>
            <value>Reading</value>
            <value>Traveling</value>
        </list>
    </property>
</bean>
```

在上述示例中，使用`list`元素来注入`hobbies`属性的List。每个`value`元素表示一个列表项。

3. Set注入：可以使用`set`元素来注入Set类型的属性。例如：

```xml
<bean id="person" class="com.example.Person">
    <property name="skills">
        <set>
            <value>Java</value>
            <value>Spring</value>
        </set>
    </property>
</bean>
```

在上述示例中，使用`set`元素来注入`skills`属性的Set。每个`value`元素表示一个集合项。

4. Properties注入：可以使用`props`元素来注入Properties类型的属性。例如：

```xml
<bean id="person" class="com.example.Person">
    <property name="config">
        <props>
            <prop key="key1">value1</prop>
            <prop key="key2">value2</prop>
        </props>
    </property>
</bean>
```

在上述示例中，使用`props`元素来注入`config`属性的Properties。每个`prop`元素表示一个属性项，使用`key`属性来指定属性名，使用元素内容来指定属性值。

通过上述方式，可以灵活地注入Map、List、Set和Properties类型的属性。根据具体的需求和情况，选择合适的注入方式来实现属性的注入。

5.使用注解实现Spring IoC

使用注解实现Spring IoC（控制反转）可以简化配置文件的编写，并提高代码的可读性。下面介绍几种常用的注解方式来实现Spring IoC。

1. @Component注解：用于标注一个类为Spring容器的组件，可以通过@ComponentScan注解来自动扫描并注册这些组件。

```java
@Component
public class Person {
    // ...
}
```

2. @Autowired注解：用于自动装配依赖对象，可以在属性、构造方法、Setter方法上使用。

```java
@Component
public class PersonService {
    @Autowired
    private PersonRepository personRepository;
    
    // ...
}
```

3. @Qualifier注解：用于指定具体的依赖对象，当有多个同类型的依赖对象时，可以使用@Qualifier注解来指定具体的对象。

```java
@Component
public class PersonService {
    @Autowired
    @Qualifier("personRepositoryImpl")
    private PersonRepository personRepository;
    
    // ...
}
```

4. @Value注解：用于注入属性值，可以直接注入基本类型、字符串、表达式等。

```java
@Component
public class Person {
    @Value("John")
    private String name;
    
    // ...
}
```

5. @Configuration注解：用于标注一个类为配置类，可以在其中定义Bean的创建和依赖关系。

```java
@Configuration
public class AppConfig {
    @Bean
    public PersonRepository personRepository() {
        return new PersonRepositoryImpl();
    }
    
    @Bean
    public PersonService personService() {
        return new PersonService(personRepository());
    }
}
```

通过以上几种注解的使用，可以实现Spring IoC的配置和依赖注入。在使用注解方式时，需要在配置文件中添加相应的注解扫描配置，以便Spring能够自动识别和管理这些注解。例如：

```xml
<context:component-scan base-package="com.example" />
```

在上述示例中，使用`<context:component-scan>`元素来指定需要扫描的包路径，Spring会自动扫描该包及其子包下的所有组件，并将其注册到容器中。

使用注解方式可以简化配置文件的编写，提高开发效率。但需要注意的是，注解方式可能会导致代码的耦合性增加，因此需要合理使用和管理注解，避免滥用。