今天完成的事情

1.使用注解方式完成注入对象

    因为要使用注解方式注入对象，所以先通知一下我们的小管家spring：

    在springapplicationContext文件中添加一句话，如图第一句：

    我们第一句就是告诉spring我想要注解方式完成注入；倒数第二行呢是把之前的注入方式注释掉了，来演示注解方式注入

    这还不够，我们还得告诉spring，给哪个注入

    （1）我们在Category属性前面加上@Autowired，就表示给Category属性注入了category1的值；另外一种方法也在图上给了，在setCategory方法前加         上@Autowired也是一样的

    （2）还可以使用@Resorce，放在Category属性前，效果也是一样，见下图：

     刚刚是对注入对象行为的注解，接下来是对Bean进行注解配置达到同样效果，首先把之前的application文件的bean配置全部删掉，写上一句：

          <context:component-scan  base-package="com.how2java.pojo"/>

     这句话是告诉spring  bean都在这个包下面了，自己去扫描吧，然后，我们要指定Bean了啊，要不然spring扫描不到：

这里在类前添加的@Component（"p"）就是指定这个类就是bean容器

    同理也要给Category类前添加这个注解，然后在Category属性前加上@Autowired让其自动注入值，就达到了之前一样的效果了

    通过学习注解，我发现注解是真的简单而且便于编写，省事儿。

2.学习AOP

    AOP，即面向切面编程；在面向切面编程中把功能分为核心功能和周边功能。

       核心功能：登陆，增删数据的功能；

       周边功能：性能统计，日志，性能管理等功能；在面向切面编程中，周边功能就被定义为切面

       核心和切面分别独立开发，再将其编织在一起，就是AOP。

    其余的知识点我就不在这里说了，都在代码的注释里面

    （1）首先准备一个业务类，作为核心功能

package com.how2java.service;

public class ProductService {
    public void doSomeService(){
        System.out.println("doSomeService");
    }
}

    （2）准备一个切面，作为周边功能

package com.how2java.aspect;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * getSignature   获取切点的签名
 * proceed  执行切点本来的业务
 */
public class LoggerAspect {
    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("start log:" + joinPoint.getSignature().getName());
        Object object = joinPoint.proceed();
        System.out.println("end log:" + joinPoint.getSignature().getName());
        return object;
    }
}

    （3）配置xml文件，xml文件最上面的那些我就省略了

<bean name="c" class="com.how2java.pojo.Category">
        <property name="name" value="category 1" />
    </bean>

    <bean name="p" class="com.how2java.pojo.Product">
        <property name="name" value="product 1" />
<!--        <property name="category" ref="c"/>   -->
    </bean>
    <bean name="s" class="com.how2java.service.ProductService">
    </bean>
    <!-- 声明一个切面，在spring中会被定义为一个bean，id是loggerAspect，位置是后面的说明-->
    <bean id="loggerAspect" class="com.how2java.aspect.LoggerAspect"/>
    <!-- 这是声明切入点，主业务类型，名字就是id后面那个,对满足expression后面条件的方法进行切面操作-->
    <aop:config>
        <aop:pointcut id="loggerCutpoint"
                      expression=
                              "execution(* com.how2java.service.ProductService.*(..)) "/>
        <!--声明切入点，辅助功能，通知定义用pointcut-ref，通过id引用切入点来实现method指定的方法。ref引用切面支持bean -->
        <aop:aspect id="logAspect" ref="loggerAspect">
            <!-- 环绕通知，为所有符合条件的主业务接入log方法的辅助功能-->
            <aop:around pointcut-ref="loggerCutpoint" method="log"/>
        </aop:aspect>
    </aop:config>
</beans>

    说明一下这里

* com.how2java.service.ProductService.*(..)

  第一个*号含义是任意返回类型；com.how2java.service.ProductService.*含义是一这串开头的类的任意方法；（..）是参数任意

    （4）准备测试类

package com.how2java.test;
 
import com.how2java.service.ProductService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.how2java.pojo.Category;
import com.how2java.pojo.Product;
 
public class TestSpring {
 
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                new String[] { "applicationContext.xml" });

        ProductService s = (ProductService)context.getBean("s");
        s.doSomeService();
    }
}

          这是运行结果

    可以看到，运行成功了，达到了预期的结果。以上就是xml方式配置AOP，接下类是注解方式配置AOP

3.注解方式配置AOP

    首先指定Bean为roductService，用@Componment

    然后用注解配置切面

package com.how2java.aspect;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.springframework.stereotype.Component;

@Aspect   //表示这是一个切面

@Component   //表示这是一个Bean

public class LoggerAspect { 

    @Around(value = "execution(* com.how2java.service.ProductService.*(..))")    //表示对括弧里的这个类的所有方法进行切面操作

    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {

        System.out.println("start log:" + joinPoint.getSignature().getName());

        Object object = joinPoint.proceed();

        System.out.println("end log:" + joinPoint.getSignature().getName());

        return object;

    }

}

    接着就是配置xml文件了，跟上次一样，全部删掉之后，告诉spring让他自己去扫描

     <context:component-scan base-package="com.how2java.aspect"/>  //定位切面

     <context:component-scan base-package="com.how2java.service"/>  //定位业务类

    <aop:aspectj-autoproxy/>  //找到被注解了的切面类并进行切面配置

    而test类不用变

    到这就实现了用注解来配置AOP

4.配置springJUnit4

    idea默认装载了junit，但是需要导入相关jar包：

    就是打钩的这三个jar包了。

    然后新建一个测试类

package com.how2java.test;

import com.how2java.pojo.Category;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


/**
 * 这个测试是建立在只有Category基础上的，就是单纯为Category类的对象注入一个category1值
 */

@RunWith(SpringJUnit4ClassRunner.class)  //表示这是一个spring测试类
@ContextConfiguration("classpath:applicationContext.xml")  //定位spring的配置文件
public class TestSpring2 {
    @Autowired  //给这个测试类装备category对象
    Category c;

    @Test  //测试代码的逻辑
    public void test(){
        System.out.println(c.getName());
    }
}

运行结果：

今天的收获

   以上

今天遇到的问题

   就是AOP了，我搜了好久，理解了好久才把它整明白

明天计划的事情

   搞jdbcTemplate，努力推进到任务一节点20吧

其实今天还是挺开心的，收获满满，但是jdbcTempalte的教程就没个合适的，实在让人难受，所以说，想问问师兄您这儿有没有给力点的教程呢？

最后，辛苦师兄审核了！