web Magic 第四天学习

1.Spring IoC

<?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">
    <!-- Spring 通过调用bean的构造方法去创建bean方法
    <bean  class="Spring.xxx.yyy.zzz.bean"></bean>
    -->
    <!--
        Spring 通过beanFactory 的 newbean 方法创建bean对象
        <bean id="tom" class="Spring.xxx.yyy.zzz.BeanFactory" factory-method="newbean"></bean>
    -->
<!--

 -->
    <bean id="factory" class="Spring.xxx.yyy.zzz.BeanFactory"/>
    <bean id="tom" factory-bean="factory" factory-method="newbean2">
    </bean>
</beans>

2.使用Java配置类

xml配置和Java代码配置间的对应关系
1…xml配置文件中有一个的配置，对等的，配置类中就会有一个方法，且方法头上有一个@Bean注解
2…xml配置文件中的</>配置，通过class="…“来说明这里（让Spring）创建的是什么类型的对象；对象的配置类中
就是通过方法的返回值类型来说明这里（让Spring）创建的是什么类型的对象
3…xml配置文件中的配置，通过id=”…"来为这个单例对象起一个唯一性的编号，用来和其他的配置来区别。对等的
配置类中，就是通过方法名来起到同样的作用
4.（代码配置的最大的灵活性和方便性，就体现在如下）
.xml配置文件中，我们是通过各种语法约定【明示】，【暗示】Spring
应该以何种方式来创建对象
以何种方式为对象的属性赋值
以何种方式来为对象的简单属性赋值，引用属性赋值。这些语法约定虽然不难，但是很繁琐，需要记忆（或者临时查询）
配置类中，上述问题，全部由程序员通过方法的代码自己实现，Spring只保证它调用这个方法，而且只调用一次，以实现获取并管理这个单例对象。
在.xml配置文件中和代码管理两种配置方法中，背后的配置【思维】有一些区别：
.xml配置文件的配置方法中，根据你所提供的【线索】，Spring类来new对象，来为其属性赋值Spring只负责调用你的这段代码，而且只调用一次
Java代码配置的配置方案中，由你【提前准备好】创建对象和为其属性赋值的代码
Spring就只用负责调动你的这段代码（而且只调用一次）来获取这个单例对象
所以，创建对象和为其属性赋值的工作就交到了程序员的手里，【你】想怎么搞写代码就行
不再需要去【记】.xml配置文件的语法规则，不用再【暗示】Spring应该怎么干达到你心里预期效果
所以使用Java代码配置的方法变得简单，变得灵活。

package Spring.xxx.yyy.zzz;

import org.springframework.context.annotation.Bean;

/**
 * xml配置和Java代码配置间的对应关系
 * 1..xml配置文件中有一个<bean></bean>的配置，对等的，配置类中就会有一个方法，且方法头上有一个@Bean注解
 * 2. .xml配置文件中的<bean></>配置，通过class="...."来说明这里（让Spring）创建的是什么类型的对象；对象的配置类中
 *      就是通过方法的返回值类型来说明这里（让Spring）创建的是什么类型的对象
 *  3. .xml配置文件中的<bean></bean>配置，通过id="......" 来为这个单例对象起一个唯一性的编号，用来和其他的配置来区别。对等的
 *  配置类中，就是通过方法名来起到同样的作用
 *  4. （代码配置的最大的灵活性和方便性，就体现在如下）
 *  .xml配置文件中，我们是通过各种语法约定【明示】，【暗示】Spring
 *  应该以何种方式来创建对象
 *  以何种方式为对象的属性赋值
 *  以何种方式来为对象的简单属性赋值，引用属性赋值。这些语法约定虽然不难，但是很繁琐，需要记忆（或者临时查询）
 *  配置类中，上述问题，全部由程序员通过方法的代码自己实现，Spring 只保证它调用这个方法，而且只调用一次，以实现获取并管理这个单例对象。
 *  在 .xml配置文件中和代码管理两种配置方法中，背后的配置【思维】有一些区别：
 *  .xml配置文件的配置方法中，根据你所提供的【线索】，Spring类来new对象，来为其属性赋值 Spring只负责调用你的这段代码，而且只调用一次
 *  Java代码配置的配置方案中，由你【提前准备好】创建对象和为其属性赋值的代码
 *  Spring就只用负责调动你的这段代码（而且只调用一次）来获取这个单例对象
 *  所以，创建对象和为其属性赋值的工作就交到了程序员的手里，【你】想怎么搞写代码就行
 *  不再需要去【记】.xml配置文件的语法规则，不用再【暗示】Spring应该怎么干达到你心里预期效果
 *  所以使用Java代码配置的方法变得简单，变得灵活。
 *
 */
public class ApplicationContext {
    /**
     *
     *   <bean id="teacher" class="Spring.xxx.yyy.zzz.Teacher">
     *         <property name="id" value="111111"/>
     *     </bean>
     */
    @Bean
    public Teacher teacher(){
        Teacher teacher=new Teacher();
        teacher.setId("zengyi");
        return teacher;
    }

    /**
     * Spring 会发现这个方法需要传入一个Teacher对象。
     * 即，逻辑上要求，在调用该方法之前，Spring IOC容器要【先】存在一个Teacher（的单例对象）
     * Spring会确保先调用上面的这个teacher() 方法。获得Teacher的单例对象
     * 然后在调用下面这个student() 传入【现在已存在了的】Teacher 对象，已获得student的单例对象
     *
     * 简而言之，Spring会发现/知道Student单例对象的创建【依赖于】Teacher单例对象的创建
     * 它会控制/管理创建这个对象的先后顺序
     * @param teacher
     * @return
     */
    @Bean
    public bean bean(Teacher teacher){
        bean b=new bean();
        b.setiD("zengyisb");
        b.setNamr("zengyi");
        b.setTeacher(teacher);
        return b;
    }
}

3.Spring AOP

1. AOP 基本概念
   显示中有一些内容并不是面向对象技术（OOP）可以解决的，比如事务处理。在 JDBC 代码中，最繁琐的问题就是无穷无尽的 try … catch … finally … 语句 和 数据库资源关闭 的问题，而且代码会存在大量的重复，而你又不能不写。

一个正常执行的 SQL 的逻辑步骤如下：

打开通过数据库连接池获得数据库链接资源，并做一定的设置工作。
执行对应的 SQL 语句（通常是增删改），对数据进行操作。
如果 SQL 执行过程中发生异常，回滚事务。
如果 SQL 执行过程中没有发生异常，最后提交事物。
到最后的阶段，需要关闭一些连接资源。

参看上述流程，你会发现无论是执行什么具体的 SQL，流程都是一样的！即，到了特定时刻一定会执行某个特定操作，并不因 SQL 的不同而不同 !

在 OOP 中，模块化单元是『类』（Class），而在 AOP 中，模块化的单元是『 切面』（Aspect）。

AOP 最早由 AOP 联盟的组织提出的，并制定了一套规范。Spring AOP 遵守 AOP 联盟的规范。

Spring 的 AOP 的底层用到两种代理机制：

JDK 动态代理

如果目标类遵循某个接口，Spring AOP 底层采用 JDK 方案生成代理对象

Cglib 动态代理

如果目标类不遵循任何接口，Spring AOP 底层采用 cglib 方案生成代理对象。

package Spring.xxx.yyy.zzz;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App2 {
    public static void main(String[] args){
        ClassPathXmlApplicationContext classPathXmlApplicationContext=new ClassPathXmlApplicationContext("applicationContext_2.xml");
        bean tom=classPathXmlApplicationContext.getBean(bean.class);
        tom.sayhello();
        System.out.println(tom.toString());
        classPathXmlApplicationContext.close();
    }
}

2.@Aspect

package Aspect;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class beanAspcet {

    @Before("execution(* Spring.xxx.yyy.zzz.bean.sayhello())")
        public void before() {
        System.out.println("before ...");
    }

    @After("execution(* Spring.xxx.yyy.zzz.bean.sayhello())")
    public void after() {
        System.out.println("after ...");
    }

}

4. jdbc配置

movie类

package bean.po;

/**
 * po 持久化对象
 * 它和数据库中的表是有一一对应的关系的
 */
public class movie {
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getDirector() {
        return director;
    }

    public void setDirector(String director) {
        this.director = director;
    }

    @Override
    public String toString() {
        return "movie{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", type='" + type + '\'' +
                ", director='" + director + '\'' +
                ", writer='" + writer + '\'' +
                ", actor='" + actor + '\'' +
                ", plot='" + plot + '\'' +
                '}';
    }

    public String getWriter() {
        return writer;
    }

    public void setWriter(String writer) {
        this.writer = writer;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }

    public String getPlot() {
        return plot;
    }

    public void setPlot(String plot) {
        this.plot = plot;
    }

    public String id;
    public String name;
    public String type;
    public String director;
    public String writer;
    public String actor;
    public String plot;
}

movieMapper类

package bean.po;

import org.springframework.jdbc.core.RowMapper;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class movieMapper implements RowMapper<movie> {
    public movie mapRow(ResultSet rs, int rowNum) throws SQLException {
        movie movie=new movie();
        /**
         *   public String id;
         *     public String name;
         *     public String type;
         *     public String director;
         *     public String writer;
         *     public String actor;
         *     public String plot;
         */
        movie.setId(rs.getString("id"));
        movie.setName(rs.getString("name"));
        movie.setType(rs.getString("type"));
        movie.setDirector(rs.getString("director"));
        movie.setWriter(rs.getString("writer"));
        movie.setActor(rs.getString("actor"));
        movie.setPlot(rs.getString("plot"));
        return movie;
    }
}

test类

package Spring.xxx.yyy.zzz;

import bean.po.movie;
import bean.po.movieMapper;
import org.Movie;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.ResultSetExtractor;

import java.util.ArrayList;
import java.util.List;


public class app4 {
    public static  void main(String[] args){
        ClassPathXmlApplicationContext classPathXmlApplicationContext=new ClassPathXmlApplicationContext("applicationContext_3.xml");
        JdbcTemplate ds= (JdbcTemplate)classPathXmlApplicationContext.getBean("jdbcTemplate");
//        ds.query("select * from movie",movieResultSetExtractor);
        List<movie> movie=ds.query("select * from movie",new movieMapper());
        for(movie movie1:movie){
            System.out.println(movie1.toString());
        }
    }
}

xml配置

<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
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:property-placeholder location="classpath:jdbc.properties" ignore-unresolvable="true" />
    <bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/scott?useUnicode=true"/>
        <property name="username" value="root"/>
        <property name="password" value="fhhsly123456"/>
    </bean>
<!--
    创建jdbcTemplate单例对象，它封装了jdbc操作
    未来，我们是直接操作jdbcTemplate

-->
    <!-- 2. 创建JdbcTemplate对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

5.MVC，老师讲的太快，没有听懂