duri 监控

转载

mob64ca140ce312 2024-11-06 22:38:40

文章标签 duri 监控 spring java 后端 xml 文章分类 运维

1spring简介

1.4

Spring Boot

一个快速开发的脚手架

基于springBoot可以快速的开发单个微服务

约定大于配置

Spring Cloud

Spring Cloud 是基于SpringBoot开发的。

弊端：

spring配置比较多。

2 IOC

新建一个项目，导入mvc包

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>
    </dependencies>

IOC是一种设计思想，DI(依赖)注入式控制反转的一种实现，在这之前，对象的新建和依赖关系完全由程序自己控制，现在，将对象的新建和依赖关系交给第三方，程序主要实现业务。新建和控制对象的为IOC容器。

2.1helloSpring

applicationContext

通过xml配的方法生成bean对象，通过修改配置文件，实现注入对象的改变，而程序完全不需要改变。

<?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">

<!-- 相当于通过配置 new 了一个叫hello的对象 -->
<bean id="hello" class="com.kuang.pojo.Hello">
    <!--属性必须由set方法，否则无法注入值-->
    <property name="str" value="helloString"/>
</bean>

</beans>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QjwPa38F-1659369598528)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20220316224443854.png)]

测试

//获取spring的上下文
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //我们的对象在spring管理，我们可以直接获取使用
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());

        //通过上下文，获取不同的bean对象
        UserService userServiceMysql = (UserService) context.getBean("userServiceMysql");
        System.out.println(userServiceMysql.getService());
        UserService userServiceOracle = (UserService) context.getBean("userServiceOracle");
        System.out.println(userServiceOracle.getService());

2.2IOC创建对象的方式

1.默认使用无参构造方法新建对象，通过set方法注入属性值

2.通过下标创建bean

<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg index="0" value="name"/>
    <constructor-arg index="1" value="12"/>
</bean>

3.通过属性名称创建bean

<bean id="user" class="com.kuang.pojo.User">
        <constructor-arg name="name" value="属性"/>
       <constructor-arg name="age" value="13"/>
    </bean>

4.通过属性类型,相同类型难处理

<bean id="user" class="com.kuang.pojo.User">
        <constructor-arg type="java.lang.String" value="了些"/>
        <constructor-arg type="int" value="17"/>
    </bean>

混合使用也是可以拿到结果

<bean id="user" class="com.kuang.pojo.User">
        <constructor-arg type="java.lang.String" value="了些"/>
        <constructor-arg name="age" value="19"/>
    </bean>

//在配置文件被加载处理完成后，bean对象就已经生成了，需要的时候自己获取

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//直接获取使用
 User user = (User) context.getBean("user");

3spring的配置

3.1别名

在配置文件中添加bean之后，在新建一个bean,这个时候，通过user T，或者userNew都可以获取到相同的bean.

<bean id="userT" class="com.kuang.pojo.UserT"/>
    <alias name="userT" alias="userNew"/>

3.2bean的配置

<!-- id:是bean的唯一标识符，相当于对象名
    class:bean对象所对应的全限定名，包名+类名
    name 相当于别名，可以取多个别名，可以用空格，也可以用逗号 分隔开-->
    <bean id="user" class="com.kuang.pojo.User" name="user2 u2 , u3">
        <constructor-arg type="java.lang.String" value="了些"/>
        <constructor-arg name="age" value="19"/>
    </bean>

3.3 import

适用于团队开发，可以将不同人写的配置文件，导入到同一个配置文件中，这样我们只需要显式的读取一个配合文件，这样所有的配置文件内容都可以被读取。

在applicationCotext.xml文件中添加以下导入，这样就可以通过读取 applicationContext.xml的配置文件上下文获取文件1.中的bean。
配置内容相同可以自动覆盖。
<import resource="applicationContext1.xml"/>

4.依赖注入

4.1构造器注入

？？？构造器无参注入

4.2set方式注入(核心注入方式)

依赖注入：set注入

依赖：bean对象的创建依赖容器

注入：bean对象的属性注入依赖容器

private String name;
    private List<Teacher> teacherList;
    private Map<String,String> bankCards;
    private Set<String> books;
    private String gf;
    private String[] games;
    private Address address;
    private Properties properties;

不同类似属性值得bean配置
    <bean id="address" class="com.kuang.pojo.Address">
        <property name="address" value="地址。。。。"/>
    </bean>
    <bean id="teacher1" class="com.kuang.pojo.Teacher">
        <property name="tName" value="胡老师"/>
    </bean>
    <bean id="teacher2" class="com.kuang.pojo.Teacher">
        <property name="tName" value="章老师"/>
    </bean>
    <bean id="teacher3" class="com.kuang.pojo.Teacher">
        <property name="tName" value="孙老师"/>
    </bean>
<bean id="student" class="com.kuang.pojo.Student">
    <property name="name" value="胡歌"/>
    <property name="address" ref="address"/>
    <!--list-->
  <property name="games">
      <array>
          <value>三年获</value>
          <value>火速</value>
          <value>宿舍</value>
      </array>
  </property>
    <!--map-->
    <property name="bankCards">
        <map>
            <entry key="苏州" value="7888887"/>
            <entry key="南京" value="8989889"/>
            <entry key="别急" value="7897878"/>
        </map>
    </property>
    <!--set-->
<property name="books">
    <set>
        <value>三国演绎</value>
        <value>水浒传</value>
        <value>西游记</value>
    </set>

</property>
    <!--null-->
    <property name="gf">
        <null/>
    </property>
    <property name="properties">
        <props>
            <prop key="学号">88383</prop>
            <prop key="username">胡给</prop>
        </props>
    </property>
</bean>

4.3拓展方式注入

p命名空间和c命名空间，首先需要在xml文件中添加约束（单独添加就可以使用）

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       //p命名空间
       xmlns:p="http://www.springframework.org/schema/p"
       //c命名空间
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    //可以直接使用，注入属性property
<bean id="teacher" class="com.kuang.pojo.Teacher" p:grade="一年级" p:tName="胡老师"/>
    //不可以直接使用，通过构造方法注入
    <bean id="teacher2" class="com.kuang.pojo.Teacher" c:grade="二年纪" c:tName="章老师"/>
</bea

测试：

ApplicationContext context = new 		ClassPathXmlApplicationContext("applicationContext.xml");
       Teacher teacher = context.getBean("teacher", Teacher.class);
        System.out.println(teacher.toString());
        Teacher teacher2 = context.getBean("teacher2", Teacher.class);
        System.out.println(teacher2.toString());

4.4bean的作用域

1单例模式

<!--scope="singleton"  默认就是单例模式，可以不写-->

<bean id="teacher" class="com.kuang.pojo.Teacher" p:grade="一年级" p:tName="胡老师" scope="singleton"/>

2 原型模式

<!--scope="prototype"  每次获取bean都会生成一个新的bean-->
<bean id="teacher2" class="com.kuang.pojo.Teacher" c:grade="二年纪" c:tName="章老师" scope="prototype"/>

3其他 request，session，application,这些只能在web开发中使用。

7注解使用的配置文件

自动装配

注意：

<bean id="cat" class="Bean.Cat"></bean>

//scope 设置bean的作用域，singleton 表示单例模式，只有一个bean
    <bean id="dog" class="Bean.Dog" scope="singleton"></bean>
 <bean id="dog2" class="Bean.Dog" scope="singleton"></bean>
//byName 仅根据id的name来装配，byType，仅根据类路径来装配,可以么有id
    <bean id="people" class="Bean.People" autowire="byName"></bean>

可以通过注解@Autowired，放在属性上来实现自动注解，
    
   //如果Autowired 定义了required属性为false，说明这个对象可以为null，否则不允许
    @Autowired(required = false)
    //有相同的name
    @Qualifier(value="cat2")
    private  Dog dog;
    @Resource(name = "cat")
    private Cat cat;

注意：

1.导入注解的约束：context

2.配置注解的支持： context:annotation-config/

<!--配置文件中添加以下内容，-->
<?xml version="1.0" encoding="UTF-8"?>

<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">
//扫描以下包com.kuang.pojo
<context:component-scan base-package="com.kuang.pojo"/>
    //引用注解必须有
    <context:annotation-config/>  

</beans>

package com.kuang.pojo;

import org.springframework.stereotype.Component;

@Component //在扫描包的时候，遇到这样的注解，则为bean
public class User {
    public void  showName(){
        System.out.println("我的名字时哈哈");
    }
}

8使用注解开发

1.bean

在spring4之后，要使用注解开发，必须保证aop的包已经导入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gyH6LeZ7-1659369598534)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20220322114211739.png)]

在使用注解开发，必须添加coentext约束，添加注解支持

<!--配置文件中添加以下内容，-->
<?xml version="1.0" encoding="UTF-8"?>

<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">
//扫描以下包com.kuang.pojo
<context:component-scan base-package="com.kuang.pojo"/>
    //引用注解必须有
    <context:annotation-config/>  

</beans>

在扫描包的java类上加上@Component注解，表示这个java类作为一个bean被spring管理，

2.属性的注入

可以在属性上添加，也可以在set方法上添加

添加了
@Component
public class User {
 @Value("狂神")
 public String name ;
 public int age;
 public void setName(String name) {
  this.name = name;
 }
 //相当于<property name="age" value = "12"/>
@Value("12")
 public void setAge(int age) {
  this.age = age;
 }

@Autowired :自动装配通过类型，或者名字
如果Autowired不能唯一自动装配，多个类型不同名称的bean，则需要通过@Qualifier(value=“xxx”)配合使用。
@Nullable 标记了这个字段，说明这个字段可以为null
@Resource :类似于@Autowired，这是一个java的注解，不属于spring里面的注解。默认byName，负责不要Type，依然没有则报错。
@Component :注解，放在类上，说明这个类被spring管理，作为bean用。

@Component
public class User {
    @Value("名字")
    public String name;
    public void  showName(){
        System.out.println("我的名字时哈哈");
    }
    public String getName() {
        return name;
    }
}

3.衍生注解

@Component有几个衍生注解，作用都是将修饰的类注册到容器中交给spring管理，安装mvc的架构区分
。Dao @Repository 主要用于和数据库交互
。service @Service 用户修饰业务层
。Controller @Controller 用来修饰控制器层

这四个注解的功能相同，都是将类注册到spring容器中,作为bean使用。

4.自动装配

@Autowired :自动装配通过类型，或者名字
 如果Autowired不能唯一自动装配，多个类型不同名称的bean，则需要通过@Qualifier(value="xxx")配合使用。
@Nullable 标记了这个字段，说明这个字段可以为null
@Resource :类似于@Autowired，这是一个java的注解，不属于spring里面的注解。默认byName，负责不要Type，依然没有则报错

5作用域

@Component
@Scope("prototype")//作用域设置
public class User {
 @Value("狂神")
 public String name ;
 public int age;
 public void setName(String name) {
  this.name = name;
 }
 //相当于<property name="age" value = "12"/>
@Value("12")
 public void setAge(int age) {
  this.age = age;
 }
}

6小结

xml配置和注解配置

1.xml配置更加万能，适合任何场景

2.注解，不是自己的类无法使用

3.最佳使用组合，xml配置用来管理bean，注解的方式用来添加属性。

9纯java类实现bean

bean对象

@Scope("sigleType")//是否单例模式设置
@Component//这个注解还是表示这个类被spring管理了
public class User {
    @Value("胡歌")
    private String name;

    public String getName() {
        return name;
    }

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

配置类

@Configuration//表示这是一个配置类，类似于beans.xml。同时这个类也是被spring管理了。
@ComponentScan("com.kuang")//扫描包用，
@Import(AppConfig2.class)//如果有多个配置类，可以通过这个方式记载到一个类里面
public class AppConfig {

    //注册一个bean，相当于写的bean标签的作用
    //这个方法的名字相当于id，
    // 返回值相当于class属性
    @Bean
    public User getUser(){
        return  new User();
    }
}

测试类

public static void main(String[] args) {
        //完全用java类实现，获取bean的方式时AnnotationConfig,上下文容器通过配置了的class对象加载
     ApplicationContext context =   new AnnotationConfigApplicationContext(AppConfig.class);
    User user =(User) context.getBean("getUser");
System.out.println(user.getName());
    }

10 代理模式

10.1静态代理

角色分析：

1.抽象角色：一般会使用接口或者抽象类

2.真是角色：被代理角色

3.代理角色：代理真是角色，代理真实角色后会增加一些附属操作

4.客户：访问被代理的对像

代码步骤

1.接口

public interface Rent {
    void rent();
}

2.真实角色

public class Host implements Rent{

    @Override
    public void rent() {
        System.out.println("房东出租了房子");
    }
}

3.代理角色

public class Proxy implements Rent{

    private Host host;

    public Host getHost() {
        return host;
    }

    public void setHost(Host host) {
        this.host = host;
    }

    @Override
    public void rent() {
        seeHost();
        hetong();
        host.rent();
        payFee();
    }

    private void seeHost(){
        System.out.println("中介带着看房");
    }

    private void hetong(){
        System.out.println("中介签合同");
    }

    private void payFee(){
        System.out.println("给中介费和房租");
    }
}

4.客户端访问

public class Client {
    public static void main(String[] args) {
        //房东要租房子
        Host host = new Host();
        //代理，中介帮忙租房子，同时会有一些附属操作
        Proxy proxy = new Proxy();
        proxy.setHost(host);
        //不需要面对中介，直接出租房子
        proxy.rent();
    }
}

代理模式的好处：

。真实角色的操作更加存粹，不需要处理公共业务

。公共业务交给代理处理，实现业务分工

。公共业务交给代理处理，方便管理

代理模式确定

。一个真实角色就一个代理角色，代码量翻倍

10.2代理模式实现aop的思想

在原有代码完全实现的情况下，如果需要在原有代码中增加日志功能，这个时候，防止对原有代码产生影响，可以用代理模式，代理类中增加日志功能，原有代码不变。需要日志的调用只要调用代理类就可以。

10.3动态代理

。动态代理类和静态代理类同样使用

。动态代理类是动态生成的，不是我们直接手写的

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

. 基于接口------JDK的动态代理

. 基于类的-----cglib

. java字节码实现----javasist

需要了解两个类 Proxy代理，InvocationHandler调用处理程序

动态代理的好处：

。真实角色的操作更加存粹，不需要处理公共业务

。公共业务交给代理处理，实现业务分工

。公共业务交给代理处理，方便管理

。一个动态代理类代理的一个接口，一般对应一类业务

。一个动态代理类可以代理多个类，只要实现了同一个接口

接口：
    public interface HostService {
    public void addHouse();
    public void deleteHouse();
    public void selectHouse();
    public void updateHouse();
}
实现接口的真实类：
    public class Host implements HostService{
    @Override
    public void addHouse() {
        System.out.println("买了套房");
    }
    @Override
    public void deleteHouse() {
        System.out.println("卖了套房");
    }
    @Override
    public void selectHouse() {
        System.out.println("巡视了房");
    }
    @Override
    public void updateHouse() {
        System.out.println("装修了套房");
    }
}
实现InvocationHandler接口的处理器：
    
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyInvocationHandler implements InvocationHandler {

    //接口
    private Object object;

    public void setObject(Object object) {
        this.object = object;
    }

    //生成代理类的方法
    public  Object getProxy(){
      return  Proxy.newProxyInstance(this.getClass().getClassLoader(),object.getClass().getInterfaces(),  this);
    }

   //反射调用方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        before();
        Object invoke =  method.invoke(object,args);
        after();
        return invoke;
    }
    private void before(){
        System.out.println("方法之前执行，");
    }
    private void after(){
        System.out.println("方法之后执行，后台通知之类");
    }
    
    客户端调用生成代理类并调用犯法：
        public class Client {
    public static void main(String[] args) {
        //真实角色
        HostService host = new Host();//对象可以是实现接口的不同对象
        //  代理角色不存在，一个生成程序
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
        proxyInvocationHandler.setObject(host);
        //得到代理类
        HostService hostService = (HostService) proxyInvocationHandler.getProxy();
        //代理类执行方法
        hostService.addHouse();
        hostService.deleteHouse();
    }

11 AOP

### 11.1 AOP概述

1.aop面向切面编程，作为oop的一个补充，主要解决纵向编程的问题

2.aop将软件分成核心关注点和横切关注点

比如：主要的业务逻辑，就是核心关注点，严重安全性，记录日志，有些事务。。。就是横切关注点

3.可能用到的场景：

权限，缓存，内容传递，错误处理，懒加载，调试，资源池，同步，记录跟踪，优化，校准，持久化。。

11.2AOP在spring中的作用

提供声明式事务；允许用户自定义切面

11.3使用spring 实现AOP

//   使用aop需要导入的包

<dependencies>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>
    </dependencies>

纵向接口和实现类：
    public interface UserService {
    public void add();
    public void del();
    public void upd();
    public void sel();
}
public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("新增加了");
    }

    @Override
    public void del() {
        System.out.println("删除了");
    }

    @Override
    public void upd() {
        System.out.println("修改了");
    }

    @Override
    public void sel() {
        System.out.println("查询了");
    }
}

横向类实现：
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class Log implements MethodBeforeAdvice {

    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println(o.getClass().getName()+"执行?"+method.getName());
    }
}

import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;//反射机制
public class AfterLog implements AfterReturningAdvice {
    @Override
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println(method.getName()+"返回?"+o);
    }
}

配置文件配置bean和aop：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">


<!--注册beans-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl" ></bean>
    <bean id="log" class="com.kuang.log.Log" ></bean>
    <bean id="afterLog" class="com.kuang.log.AfterLog" ></bean>
    <!--使用原生spring API接口-->
<!--注册aop-->
    <aop:config>
        <!--expression表示切入点  execution(表达式 修饰此public 返回值 类名 方法名 参数)-->
            <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

测试：
    
    public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        //这里必须是接口对象来接收(代理类)
        UserService userService=context.getBean("userService", UserService.class);
        userService.add();
        userService.del();
    }
}

11.4自定义类实现AOP 自己写切面

自定义要给方法类，作为切面
public class DiyPointCut {
    public  void before(){
        System.out.println("====方法之前执行=====");
    }


    public  void after(){
        System.out.println("====方法之前后执行=====");
    }
}

配置AOP切面，两个方法都保留作为比较


<!--注册beans-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl" ></bean>
    <bean id="log" class="com.kuang.log.Log" ></bean>
    <bean id="afterLog" class="com.kuang.log.AfterLog" ></bean>
    <!--方式一   使用原生spring API接口-->
<!--注册aop-->
    <!--<aop:config>
        <!–expression表示切入点  execution(表达式 修饰此public 返回值 类名 方法名 参数)–>
            <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>-->

    <!--方式二  使用类来实现-->
//定义切面的bean
    <bean id="diy" class="com.kuang.diy.DiyPointCut"></bean>
//配置AOP
    <aop:config>
        <aop:aspect ref="diy">//切面
            <aop:pointcut id="pointCut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
            <aop:after method="after" pointcut-ref="pointCut"></aop:after>
            <aop:before method="before" pointcut-ref="pointCut"/>
        </aop:aspect>
    </aop:config>
</beans>

12spring整合mybatis

1.引入约束

<dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.25</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!--spring操作数据库需要spring-jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.13</version>
        </dependency>
        <!-- aspectjweaver 处理事务和AOP所需的包 -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>
        <!--spring整合mybatiS需要用到的包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.7</version>
        </dependency>
</dependencies>
    <!--静态资源过滤问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

2mybatis-spring

在spring整合mybatis的配置文件xml

1.通过spring提供的文档配置数据源

<!--配置数据源，用spring的数据源代替mybatis的数据源配置,可以选择c3p0,dbcp,druid等方式，这里选择
org.springframework.jdbc.datasource,使用spring提供的数据源
-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSl=true&useUnicode=true&characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="987cde@"/>
    </bean>

2.配置sqlSessionFactory的bean

<!--要和 Spring 一起使用 MyBatis，需要在 Spring 应用上下文中定义至少两样东西：一个 SqlSessionFactory 和至少一个数据映射器类。
在 MyBatis-Spring 中，可使用 SqlSessionFactoryBean来创建 SqlSessionFactory。 要配置这个工厂 bean，只需要把下面代码放在 Spring 的 XML 配置文件中-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--可以绑定mybatis，减少mybatis配置文件的内容-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/kuang/dao/*.xml"/>
    </bean>

3注入sqlSessionTemplate的bean

<!--SqlSessionTemplate 就是我们在mybatis中的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--么有set方法，只要通过构造器注入参数-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

4.配置接口实现类的bean

<bean id="userMapper" class="com.kuang.dao.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

5.接口的实现

public class UserMapperImpl implements UserMapper{

public SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    @Override
    public User getUser(int userId) {
        return sqlSession.getMapper(UserMapper.class).getUser(userId);
    }
}

6.测试

public void getUser(){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
        UserMapper userMapper =context.getBean(UserMapper.class);
       User user= userMapper.getUser(1);
        System.out.println(user.toString());
    }

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：i2c mem 协议

下一篇：haproxy 对那些服务能做健康检测

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

duri 监控

duri 监控

1spring简介

2 IOC

2.1helloSpring

2.2IOC创建对象的方式

3spring的配置

3.1别名

3.2bean的配置

3.3 import

4.依赖注入

4.1构造器注入

4.2set方式注入(核心注入方式)

4.3拓展方式注入

4.4bean的作用域

7注解使用的配置文件

自动装配

8使用注解开发

1.bean

2.属性的注入

3.衍生注解

4.自动装配

5作用域

6小结

9纯java类实现bean

10 代理模式

10.1静态代理

10.2代理模式实现aop的思想

10.3动态代理

11 AOP

11.2AOP在spring中的作用

11.3使用spring 实现AOP

11.4自定义类实现AOP 自己写切面

12spring整合mybatis

1.引入约束

2mybatis-spring

51CTO博客