Spring5

1.IOC(Inversion of Control)概念和原理

引例：

在UserService类中调用UserDao中的方法是耦合度很高！UserDao更改，Userservice也需要更改

因此可以使用工厂模式降低耦合：

此时降低到了最大限度的耦合，但在IOC中也通过这种模式来降低耦合：

2.IOC接口

 我们通常使用ApplicationContext接口实现所有类，代码如下：

//简单的创建类的配置文件   
 

 @Test
    public void testAdd(){
        //加载spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        //获取配置创建的对象,控制反转的体现,id+对应的class
        User user=context.getBean("user",User.class);
        System.out.println(user);
        user.add();
    }

3.IOC操作Bean管理（基于XML注入属性）

①set方法注入属性

public class Book {
 //创建属性
 private String bname;
 private String bauthor;
 //创建属性对应的 set 方法
 public void setBname(String bname) {
 this.bname = bname;
 }
 public void setBauthor(String bauthor) {
 this.bauthor = bauthor;
 }
}

在Spring配置文件配置对象创建，配置属性注入（使用property）：

注入空值：

注入特殊符号：

 >]]>

②使用有参构造注入属性

public class Orders {
 //属性
 private String oname;
 private String address;
 //有参数构造
 public Orders(String oname,String address) {
 this.oname = oname;
 this.address = address;
 }
}

在 spring 配置文件中进行配置（使用constructor-arg）：

③注入外部bean

1. 创建两个类service 类和 dao 类
2. 在 service 调用 dao 里面的方法
3. 在 spring 配置文件中进行配置

UserDao重写update方法

public class UserDaoImpl implements UserDao{
    @Override
    public void update() {
        System.out.println("dao update...");
    }
}

UserService调用到dao中update方法：

public class UserService {
    //创建UserD奥类型属性，生成set方法
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        System.out.println("srvice add....");
        userDao.update();

//        //原始方式：,创建UserDao对象..
//        UserDao userDao=new UserDaoImpl();
//        userDao.update();
    }
}

xml中的配置：

④注入内部bean

⑤注入属性-级联赋值

（1）第一种写法

（2）第二种写法

需要生成get方法 

通过dept.dname的方式

4.IOC 操作 Bean 管理（基于xml 注入集合属性）

1、注入数组类型属性

2、注入 List 集合类型属性

3、注入 Map 集合类型属性

（1）创建类，定义数组、list、map、set 类型属性，生成对应 set 方法

public class Stu {
 //1 数组类型属性
 private String[] courses;
 //2 list 集合类型属性
 private List list;
 //3 map 集合类型属性
 private Map maps;
 //4 set 集合类型属性
 private Set sets;
 public void setSets(Set sets) {
 this.sets = sets;
 }
 public void setCourses(String[] courses) {
 this.courses = courses;
 }
 public void setList(List list) {
 this.list = list;
 }
 public void setMaps(Map maps) {
 this.maps = maps;
 }
}

（2）在 spring 配置文件进行配置

 
     
         
             java 课程
             数据库课程
         
     
 
     
         
             张三
             小三
         
     
 
     
         
     
 
     
         
             MySQL
             Redis
         
     

4、在集合里面设置对象类型值

5、把集合注入部分提取出来

（1）在 spring 配置文件中引入名称空间 util

（2）使用 util 标签完成 list 集合注入提取

    易筋经
    九阴真经
    九阳神功



     

5. IOC 操作 Bean 管理（FactoryBean）

1、Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）

2、普通 bean：在配置文件中定义 bean 类型就是返回类型

3、工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样 第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean 第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型

实现的接口中需要如下定义：

public class MyBean implements FactoryBean {
 //定义返回的bean
 @Override
 public Course getObject() throws Exception {
 Course course = new Course();
 course.setCname("abc");
 return course;
 }
 @Override
 public Class getObjectType() {
 return null;
 }
 @Override
 public boolean isSingleton() {
 return false;
 }
}

Spring配置文件xml中

最终实现了返回bean类型从mybean更改为course

@Test
public void test3() {
 ApplicationContext context =
 new ClassPathXmlApplicationContext("bean3.xml");
 Course course = context.getBean("myBean", Course.class);
 System.out.println(course);
}

6.IOC 操作 Bean 管理（xml 自动装配）

1、什么是自动装配：根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入

2、演示自动装配过程

（1）根据属性名称自动注入

（2）根据属性类型自动注入

7.IOC 操作 Bean 管理(基于注解方式)

1、什么是注解

（1）注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值..)

（2）使用注解，注解作用在类上面，方法上面，属性上面

（3）使用注解目的：简化 xml 配置

2、Spring 针对 Bean 管理中创建对象提供注解

（1）@Component

（2）@Service

（3）@Controller

（4）@Repository

* 上面四个注解功能是一样的，都可以用来创建 bean 实例

3、基于注解方式实现对象创建

• 开启组件扫描

• 创建类，在类上面添加创建对象注解

//在注解里面 value 属性值可以省略不写，
//默认值是类名称，首字母小写
//UserService -- userService
@Component(value = "userService") //
public class UserService {
 public void add() {
 System.out.println("service add.......");
 }
}

 4、开启组件扫描细节配置

Autowired:

5.基于注解方式实现属性注入 ①@Autowired：根据属性类型进行自动装配

第一步 把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解

@Repository
public class UserDaoImpl implements UserDao {
    @Override
    public void update() {
        System.out.println("dao update...");
    }
}

@Service
public class Userservice {


    private UserDao userDao;

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

第二步 在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解

@Service
public class Userservice {

    //定义dao类型
    //添加注入属性注解，实现属性的注入
    @Autowired
    private UserDao userDao;

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

②. @Qualifier：根据名称进行注入这个@Qualifier 注解的使用，和上面@Autowired 一起使用

在类上的注解需要定义对应扫描的value：

//默认是类的开头字母小写，加上value使Qualifier找到对应的value
@Repository（value="userDaoImpl1"）
public class UserDaoImpl implements UserDao {
    @Override
    public void update() {
        System.out.println("dao update...");
    }
}

对应在添加属性注解的设置 ：

//定义 dao 类型属性
//不需要添加 set 方法
//添加注入属性注解
@Autowired //根据类型进行注入
//根据名称进行注入，可以指定实现类，避免一个接口有多个实现类
@Qualifier(value = "userDaoImpl1") 
private UserDao userDao;

③@Resource：可以根据类型注入，可以根据名称注入

不是spring中的，更建议用前两个

//@Resource //根据类型进行注入
@Resource(name = "userDaoImpl1") //根据名称进行注入
private UserDao userDao;

④注入普通类型属性

可直接注入name为abc

@Value(value = "abc")
private String name;

6.完全注解开发

（1）创建配置类，替代 xml 配置文件

@Configuration //作为配置类，替代 xml 配置文件
@ComponentScan(basePackages = {"com.atguigu"})

public class SpringConfig {
}

 （2）编写测试类

@Test
public void testService2() {
 //加载配置类
 ApplicationContext context
 = new AnnotationConfigApplicationContext(SpringConfig.class);
 UserService userService = context.getBean("userService", 
UserService.class);
 System.out.println(userService);
 userService.add();
}

7.AOP概念和底层原理 AOP概念：

（1）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得 业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

（2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能（模块）。

AOP底层原理：

1、AOP 底层使用动态代理

（1）有两种情况动态代理

第一种：有接口情况，使用 JDK 动态代理 

• 创建接口实现类代理对象，增强类中的方法

 第二种：没有接口情况，使用 CGLIB 动态代理

• 创建子类的代理对象，增强类的方法

//原始方式继父类方法，重写父类

 8AOP术语和准备

AOP术语

• 连接点：类中的那些方法可以被增强，add（）、update（）...
• 切入点：实际被增强的方法
• 通知（增强）

（1）实际增强的逻辑部分成为通知

（2）通知的类型：

        前置通知、后置通知、环绕通知、异常通知、最终通知

• 切面：把通知应用到切入点过程

AOP准备

1、Spring 框架一般都是基于 AspectJ 实现 AOP 操作

（1）AspectJ 不是 Spring 组成部分，独立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使 用，进行 AOP 操作

2、基于 AspectJ 实现 AOP 操作

（1）基于 xml 配置文件实现

（2）基于注解方式实现（使用）

3、切入点表达式

（1）切入点表达式作用：知道对哪个类里面的哪个方法进行增强

（2）语法结构： execution([权限修饰符] [返回类型] [类全路径] [方法名称]([参数列表]) )

• 举例 1：对 com.atguigu.dao.BookDao 类里面的 add 进行增强 execution(* com.atguigu.dao.BookDao.add(..))
• 举例 2：对 com.atguigu.dao.BookDao 类里面的所有的方法进行增强 execution(* com.atguigu.dao.BookDao.* (..))
• 举例 3：对 com.atguigu.dao 包里面所有类，类里面所有方法进行增强 execution(* com.atguigu.dao.*.* (..))

9.通过注解方法进行AOP操作

1、创建类，在类里面定义方法

麻了写了半天的东西被撤销了。。。。。