Spring的两大特征

• ioc是一个bean容器，以前是通过new的方式主动获取一个对象而现在可以通过spring的ioc容器被动给我们提供一个对象，从而使我们获取对象的能力的到了反转

• 环境不一样，可能使用的数据库的地址也可能不一栏

• MyBatis可以配置多数据源，可以使用不同的数据库

• DI：依赖注入

  • 1.通过set方法注入值

  • 2.通过构造函数注入

  • 3.通过动p标签赋值

• 生产

• 灰度

• 测试

• 开发

package service;

public interface UserService {

    void addUser();
}

package service.impl;

import dao.UserDao;
import service.UserService;

public class UserSericeImpl implements UserService {

    //UserDao userDao=new UserDaoImpl();

    //父类接口是可 以new子类的
    //UserDao userDao=new UserMySQLDaoImpl();

    //现在是主动拿，被动获取
    //UserDao userDao=new UserOracleDaoImpl();

    //在当前类中,依赖另外一个类,但是暂时还没有给另外一个类赋值
    //DI:依赖注入
    private UserDao userDao;

    private String a;

    public UserSericeImpl() {
    }

    
    //1.通过set方法注入值
    //2.通过构造函数注入
    //3.通过动p标签赋值
    public  UserSericeImpl(UserDao userDao,String a) {
        this.userDao = userDao;
        this.a=a;
    }


    @Override
    public void addUser() {
        userDao.addUser();
    }

    @Override
    public String toString() {
        return "UserSericeImpl{" +
                "a='" + a + ''' +
                '}';
    }
}

import demo.HelloSpring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.impl.UserSericeImpl;

public class Test {
    public static void main(String[] args) {
        //虽然可以在客户端指定需要用什么环境,但是并没有实质性的解问题
        

        //这里是可以配置多个xml文件的
        ///虽然代码的复杂度提高了,但是程序的耦合性降低了
        //获取应用程序上下文
        ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 获取bean,通过Bean的id去获取
        //通过IOC的Bean可以获取一个类
        UserSericeImpl userSericeImpl = (UserSericeImpl)ioc.getBean("userSericeImpl");

        //通过类的实例调用方法
        userSericeImpl.addUser();

        System.out.println(userSericeImpl.toString());

        HelloSpring helloSpring = (HelloSpring) ioc.getBean("helloSpring");

        System.out.println(helloSpring.toString());
    }
}

• 面向切面是让程序专心做事，底层使用动态代理模式实现的

• aop使用范围特别广

  • 特别广日志收集

    • 登录日志

  • 异常处理

  • 持久化

• 切入点(Pointcut)

• 连接点(Join Point)

• 切面(Aspect)

• 目标对象.(Target object).

• AOP代理(AOP proxy)

• 织入(Weaving)

• 增强处理(Advice)

  • 前置增强

  • 后置增强

  • 环绕增强

  • 异常抛出增强

  • 最终增强等类型

• xm文件的地址，需要注意

  • 1、public * addNewUser (entity.User): *表示匹配所有类型的返回值

  • 2、public void * (entity.User) : * 表示匹配所有方法

  • 3、public void addNewUser (..) : ..匹配任意参数个数及类型

  • 4、* com.service. * . * (..)匹配com.service包下所有的类的所有方法

  • 5、* com.service.. * . * (..)匹配com.service包及其子包下所有的类的所有方法

log4j.rootLogger=debug, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

#Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%5p [%t](%F:%L)- %m%n

1og4j.appender.R=org.apache.1og4j.RollingFileAppender
log4j.appender.R.File=example.log

log4j.appender.R.MaxFileSize=10OKB
# Keep one backup file
log4j.appender.R.MaxBackupIndex=5

log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

package service;

public interface UserService {

    
    void addUser();

    
    void delUser();
}

package service.impl;

import org.apache.log4j.Logger;
import service.UserService;

public class UserServiceImpl implements UserService {
    private Logger logger=Logger.getLogger(UserServiceImpl.class);

    @Override
    public void addUser() {
        
        System.out.println("添加了一个用户");
        //使用异常
        //int i=1/0;
    }

    @Override
    public void delUser() {
        
        System.out.println("删除了一个用户");
    }
}

第四步：xml文件