1-Spring-常见概念

Spring概念

1. Spring是一个开源的轻量级框架
2. Spring是一站式框架

IOC（控制反转）（XML）

1 IOC底层原理

（1）xml配置文件
（2）dom4j解析xml
（3）工厂模式
（4）反射

2 IOC操作-入门（XML）

（1）导入jar包

（2）导入约束

<?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-3.0.xsd
        "></beans>

（3）配置xml

<bean id="user" class="com.wzw.spring.day1_rumen.User"></bean>

3 IOC中的bean管理（XML）

（1）bean实例化的三种方式

1 使用类的无参构造创建

<bean id="user" class="com.wzw.spring.day1_rumen.User"></bean>

2 使用静态工厂创建
3 使用实例工厂创建

（2）Bean标签常用属性

<bean id="" class="" scope=""></bean>

scope属性：
singleton：默认值，单例，创建的是同一个对象
prototype：多例（action是多例的，使用prototype）
request：web项目中，Spring创建一个bean对象，将对象存入request域中
session：web项目中，Spring创建一个bean对象，将对象存入session域中
globalSession：（相当于一个全局session）web项目中，应用在porlet环境，如果没有porlet环境那么globalSession相当于session

（3）IOC和DI区别

• IOC：控制反转，把对象创建交给Spring进行配置管理
• DI：依赖注入，创建对象过程中，向类里面的属性设置值
  -关系：DI不能单独存在，需要在IOC基础之上

4 ！属性注入的三种方式（XML）

创建对象时，向类里属性注入值；Spring框架只支持有参构造和set方法

（1）有参构造注入

<!-- 3.1 根据有参的构造方法来属性注入 -->
<bean id="stu" class="com.wzw.spring.Student">
    <constructor-arg name="name" value="张三"></constructor-arg>
</bean>

（2）set()方法注入（常用）

<!-- 3.2 通过set方法来注入属性  -->
<bean id="book" class="com.wzw.spring.Book">
    <property name="bookName" value="西游记"></property>
</bean>

（3）接口注入

5 ！注入对象类型属性（XML）

创建Service层实例和Dao层实例，Service实例调用Dao实例

<!-- 4 对象通过set方法来注入属性 -->
<!-- 4.1 首先创建Dao实例 -->
<bean id="userDao" class="com.wzw.spring.UserDao"></bean>
<!-- 4.2 然后创建service实例，并通过set方法来注入属性 -->
<bean id="userService" class="com.wzw.spring.UserService">
    <!-- set方法来注入属性
        name：service类里面属性名称
        ref：注入属性所对应类的id
     -->
    <property name="userDao" ref="userDao"></property>
</bean>

6 ！注入复杂数据类型属性（XML）

测试类

/*
     * 注入复杂类型属性
     */
    private String[] arrs;
    private List<String> list;
    private Map<String, String> map;
    private Properties properties;

    public void setArrs(String[] arrs) {
        this.arrs = arrs;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

Xml配置文件

    <!-- 5 注入复杂类型属性 -->
    <bean id="person" class="com.wzw.spring.Person">
        <!-- 5.1 array -->
        <property name="arrs">
            <array>
                <value>a</value>
                <value>b</value>
                <ref bean="book"/>
            </array>
        </property>

        <!-- 5.2 list -->
        <property name="list">
            <list>
                <value>aa</value>
                <value>bb</value>
                <value>cc</value>
            </list>
        </property>

        <!-- 5.3 map -->
        <property name="map">
            <map>
                <entry key="aaa" value="d"></entry>
                <entry key="bbb" value="e"></entry>
                <entry key="ccc" value="f"></entry>
            </map>
        </property>

        <!-- 5.4 properties -->
        <property name="properties">
            <props>
                <prop key="aaaa">dd</prop>
                <prop key="bbbb">ee</prop>
                <prop key="cccc">ff</prop>
            </props>
        </property>
    </bean>

IOC（注解）

1 Spring注解开发准备

（1）导入jar包

（2）导入约束

xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd

（3）xml配置

<!-- 1  注解 -->
<!-- 1.1 开启注解扫描 扫描类，方法，属性上的注解 -->
<context:component-scan base-package="com.wzw.spring"></context:component-scan>
<!-- 1.2 扫描属性上的注解 -->
<!-- <context:annotation-config></context:annotation-config> -->

2 创建对象并注入属性

（1）XML配置文件中创建对象

<!-- 2 xml创建对象 注解方式注入属性 -->
<bean id="abService" class="com.wzw.spring.service.ABService"></bean>
<bean id="aDao" class="com.wzw.spring.dao.ADao"></bean>
<bean id="bDao" class="com.wzw.spring.dao.BDao"></bean>

（2）Model层

@Component(value="user")
public class User {
    @Value("zhangsan")
    private String username;
    @Value("123")
    private String password;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public User() {
        super();
    }
    public User(String username, String password) {
        super();
        this.username = username;
        this.password = password;
    }
    @Override
    public String toString() {
        return "User [username=" + username + ", password=" + password + "]";
    }

}

（3）Dao层

@Repository(value="userDao2")
public class UserDao2 {
    @Resource(name="user")
    private User user;

    public User getInfo(){
        return user;
    }
}

（4）Service层

@Service(value="userService")
public class UserService {
//  @Autowired
// @Qualifier(“userDao”)
    @Resource(name="userDao")
    private UserDao userDao;

    public void say() {
        System.out.println("service...");
        userDao.say();
    }
}

• @Component(value=”id名”)
  //
• @Controller
• @Service（value=”id名”）
• @Repository(value=”id名”)
• @Scope(scopeName=”prototype”)
• @Resource(name=”id名”)
• @Value(“属性值”)
• @Autowired

AOP（面向切面编程）

1 AOP概念

• 扩展功能不需要修改源代码
• AOP采取横向抽取机制，取代了传统纵向抽取机制的重复性代码

2 AOP底层原理

3 AOP术语

Joinpoint（连接点）：类里面可以被增强的方法
Pointcut（切入点）：类中实际被增强的方法
Advice（通知/增强）：增强的逻辑（功能）（前置、后置、环绕、异常、最终增强）
Aspect（切面）：把增强应用到具体方法上的过程
Introduction（引介）：
Target（目标对象）：要增强的类
Weaving（织入）：把advice应用到target的过程，
Proxy（代理）：

4 ！AOP操作（XML）

（1）导入jar包

（2）导入约束

xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd

（3）配置xml文件

<!-- AOP 切面编程 -->
<!-- 1 配置对象 -->
<bean id="car" class="com.wzw.spring.model.Car"></bean>
<bean id="myCar" class="com.wzw.spring.aop.MyCar"></bean>
<!-- 2 配置aop操作 -->
<aop:config>
    <!-- 2.1 配置切入点 -->
    <aop:pointcut expression="execution(* com.wzw.spring.model.Car.*(..))" id="pointcut1"/>
    <!-- 2.2 配置切面 -->
    <aop:aspect ref="myCar">
        <aop:before method="before1" pointcut-ref="pointcut1"/>
        <aop:after-returning method="after1" pointcut-ref="pointcut1"/>
        <aop:around method="around1" pointcut-ref="pointcut1"/>
    </aop:aspect>
</aop:config>

（4）环绕增强

    //环绕增强
    public void around1(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        //方法前
        System.out.println("方法之前。。。");

        //执行被增强的方法
        proceedingJoinPoint.proceed();

        //方法后
        System.out.println("方法之后");
    }

5 AOP操作（注解）

（1）导入jar包和约束，并配置xml文件

<!-- 1 aop注解方式 -->
<!-- 1.1 创建对象 -->
<bean id="book" class="com.wzw.spring.model.Book"></bean>
<bean id="myBook" class="com.wzw.spring.aop.MyBook"></bean>
<!-- 1.2 开启aop注解扫描 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

（2）创建advice类，并注解

@Aspect
public class MyBook {
    @Before(value="execution(*com.wzw.spring.model.Book.*(..)))
    public void before1() {
        System.out.println("前置增强...");
    }
}

Spring事务