初识spring框架＜1＞

1. 1Spring是一个轻量级的DI、IOC与AOP的容器框架
2. 轻量级:使用更加简单(功能不够强大)
3. DI(依赖注入)/IOC(控制反转):->spring创建对象把对象给你
4. AOP:面向切面编程-》解决重复代码
5. 容器:面向过程->面向对象->面向接口->面向工厂
   (解耦)装的都是对象
6. 高内聚低耦合
7. spring作为工厂使用
8. spring帮我们整合外面的框架

1. 导包
   Spring以前是一个jar包，后面变成了一堆jar包
   core:核心包----产生Spring
   bean:想要–创建对象，必须要bean
   context:扩展spring功能
   expression:表达式包(有它之后才能写XML中写
   logging:日志包（是一个依赖包，不导入的话会报错）

2. 写配置

3. 拿核心对象(启动框架)–的三种方式–（BeanFactory）

   public void testHello() {
           //获得核心配置文件
           Resource classPathResource = new ClassPathResource("applicationContext.xml");
           //拿到核心对象
           BeanFactory Factory = new XmlBeanFactory(classPathResource);
           //拿到配置对象
           //更根据名称获取bean的方式。。第一种
   
           //HelloBean helloBean = (HelloBean)Factory.getBean("HelloBean");
           //第二种..根据类型获取bean对象---缺陷不能出现多个类型
           HelloBean bean = Factory.getBean("helloBean",HelloBean.class);
           System.out.println(bean);
       }
   

   4.集成启动框架的策葎–使用（ApplicationContext）

   public void testHello02(){
           ClassPathXmlApplicationContext Factory = new ClassPathXmlApplicationContext("applicationContext.xml");
           HelloBean helloBean = Factory.getBean("helloBean", HelloBean.class);
           System.out.println(helloBean);
       }
   

   • BeanFactory和ApplicationContext的区别

   BeanFactory使用的时懒加载策略，当你用的时候我才创建出来

   懒加载：用到的时候才创建
   ApplicationContext是及时加载策略,框架已启动自动创建

public class Mybean {
    
    private Yourbean yourbean;
    public void save(){
        System.out.println("yourbean"+yourbean);
    }
}

运行结果：

可以直接设置值

@Autowired:在Spring只要看到这个注解就会直接将你要的对象注入进来

1. 导包：Test(测试),aop包(面向切面)
   在测试中用到了面向切面的功能
2. 搭建环境:咱们得想个办法:在运行这个类之前，Spring就已经运行起来了(测试类中夹注解)@Runwith(SpringJUnit4ClassRunner.class)
   这个注解告诉你:这个测试是使用Spring的测试来完成ContextConfiguration:上下文配置->读取配置文件
   我们可以配置路径:classpath : applicationContext.xml
   如果你没有配置路径，它默认会去找=〉当前类名-Context.xml文件(SpringTest-Context .xml
3. 获到spring中的对象（使用注解注入)Autowired
   private scopeBean scopeBean;

​ Spring创建的对象单例的还是多例的
​ 将Spring创建的对象变为多例在xml配置文件中加入scope=“prototype”
​ 配置文件
​ 及时加载(使用时才创建)转换为懒加载(在创建完类之后才创建出来)

在bean中加lazy-init="true"实现对象个体的懒加载

1. scope:作用域
   默认的bean都是单例的,通过配置scope="prototype"改成多例
   

2. 懒加载

3. Bean的生命周期:创建，初始化，销毁

• 自动装配
• Spring会在上下文中自动寻找,并给bean装配属性

在Spring中的三种装配方式

• 在xml中显示的配置(中使用autowise="byName"来实现bean的自动装配)

  • byName自动装配
  • byType自动装配

  小结:byname的时候需要保证所有bean的唯一，并且都有唯一的自动属性注入set方法的值一致

  bytype的时候需要保证bean的class唯一,并且这个bean需要和自动注入的属性类型一致

  • 使用注解实现自动装配

• 在java中显示配置

• 隐式的自动装配bean

• 详解动态代理的模式

• 动态代理的代理类时东陶生成的不是我们直接写好的

• 动态代理分为两大类：基于接口的动态代理，基于类的动态代理

  • 基于接口----JDK动态代理
  • 基于类
  • java字节码的实现

需要了解两个:Proxy,incocationHandler(调用处理程序)

概念：面向切面编程通过预编译

< ! ----

< !---->
< ! ---->
                                               
                                               
< ! --方式二:自定义类-->







                                               
                                               
@Aspect //标注这个类是一个切而public class AnnotationPointcut i
@Before( "execution(* com.kuang.service.UserServiceImpl.*(..))")public void before(){
system.out.printin("=====方法执行前======");
}
@After( "execution(*com.kuang.service.UserServiceImp1.*(..))")public void after()i
system.out.print1n( "=====方法执行后======");
}
//在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点;@Around("execution(* com.kuang.service.UserService1mpl.*(..))")public void around(ProceedingJoinPoint jp) throws Throwable {
System.out.println("环绕前");
signature signature = jp.getsignature();//获得签名System.out.println("signature : "+signature) ;
object proceed = jp.proceed();1/执行方法system.out.println("环绕后");
system.out.println(proceed);
}