SSM使用

最新推荐文章于 2023-02-19 20:27:26 发布
VIP文章 最新推荐文章于 2023-02-19 20:27:26 发布
阅读量513 收藏 1
点赞数
分类专栏： Java 文章标签： ssm java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yandajiangjun/article/details/117993489
版权

SSM使用说明

一.Mybatis使用说明

工具: 不需要tomcat服务器，只需要数据库
xml配置: 只需要写domain类和dao接口，不需要写接口实现类，在resource目录下写sqlconfigmap.xml,里面配置数据库驱动链接，typelias标签里配置domain的路径，以达到简写目的，在写set标签，里面配置dao接口和dao接口配置文件的路径，以达到简写目的；dao接口写的是抽象方法，dao接口的配置文件，里面写的是sql语句，其中sql语句的id对应的是dao接口的抽象方法名。然后就可以写测试类，里面配置好sql对象，factory工厂。
注解配置: 只需要写domain类和dao接口，在resource目录下写sqlconfigmap.xml,里面配置数据库驱动链接，typelias标签里配置domain的路径，以达到简写目的，在写set标签，里面配置dao接口的路径，以达到简写目的；不需要写接口实现类；dao接口写的是抽象方法，然后再抽象方法上写sql语句。然后就可以写测试类，里面配置好sql对象，factory工厂。
扩展: 上面的配置都是基本配置，可以实现单表查询，但对于多对一，一对多，多对多，缓存，还需要在类，接口方法，配置文件，上做额外的配置。
延迟加载: 适用于一对多，多对多，在sqlmap开启延迟加载开关，dao.xml文件需要你修改result,然后修改一对多查询语句，同时添加一句根据id查询账户信息的语句，两者搭配使用，不然之前一对多的查询，直接把两个表都查询了，这样就没法使用延迟加载，注意UserDao接口也要多写一句根据id查询账户信息的方法。当然你想让多对一，一对一也实现同样方法的话，也只需设置同样的配置即可。
缓存: 一级缓存sqlSession对象mybatis给我们实现了，不用管，二级缓存SqlSessionFactory需要我们自己设置，但是SqlSessionFactory只是存放数据，不存放sqlSession对象，所以打印的数据一样，但是两个数据对象不相等，因为对象地址不一样。二级缓存需要在sqlmap配置缓存开关，然后在需要缓存机制的dao.xml文件里开启cache（）
注解实现全功能: 既简单也实现了延迟加载和缓存，就是UserDao接口填写缓存注解配置时，太棒了。但是注意UserDao借口开启的缓存注解会跟一对多查询语句冲突。

二.Spring使用说明

1.基于xml的ioc入门

1.导入spring-context 5.2.13.RELEASE，里面就包含了bean,core,expression,还有aop,jcl依赖，是个不简单的依赖。
2.建一个bean.xml(名字可以随便起，但因为使bean对象，最好起bean)文件，里面传入xmlns约束(打开https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#spring-core网址，按ctrl+f,搜索xmlns）

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

3.在bean文件里写bean标签，把对象的创建交给spring来管理

<bean id="accountServive" class="ioc_xml.service.impl.AccountServiceImpl"></bean>
<bean id="accountDao" class="ioc_xml.dao.impl.AccountDaoImpl"></bean>

4.模拟表现层（用来调用业务层）

/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {
   
    /**
     * 获取spring的ioc核心容器，并根据id获取对象
     * ApplicationContext的三个常用实现类：
     *      ClassPathXmlApplicationContext：它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了(相比较下面一个，这个更常用)
     *      FileSystemXmlApplicationContext:他可以加载磁盘任意路径下的配置文件(必须有访问权限)
     *      AnnotationConfigApplicationContext:用于读取注解创建的容易内容
     *
     * 核心容器的两个接口引发的问题
     *      ApplicationContext：单例对象适用。但ApplicationContext接口很智能，能够根据对象是单例或多例来采取是延迟加载还是立即加载的方式，所以更偏向采用此接口
     *          他在构建核心容器时，创建对象采取的策略是立即加载的方式，也就是说，一读取完配置文件，马上就采用反射的方式，创建配置文件中配置的对象
     *      BeanFactory:  多例对象适用
     *          他在构建核心容器时，创建对象采取的策略是延迟加载的方式，也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象
     * @param args
     */

    public static void main(String[] args) {
   
        //采用ApplicationContext创建对象，也是演示ApplicationContext创建对象的过程
        //1.获取核心容器对象
        ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
//        ApplicationContext ac=new FileSystemXmlApplicationContext("F:\\springFrame\\src\\main\\resources\\bean.xml");
        //2.根据id获取Bean对象
        IAccountService is=(IAccountService)ac.getBean("accountServive");//把object对象，强转成IAccountService对象
        IAccountDao iad=ac.getBean("accountDao",IAccountDao.class);//通过字节码强转得到我们想要的对象
        System.out.println(is);
        System.out.println(iad);

        //演示BeanFactory创建对象过程
/*        Resource resource=new ClassPathResource("bean.xml");
        BeanFactory factory=new XmlBeanFactory(resource);
        IAccountService is=(IAccountService)factory.getBean("accountServive");
        System.out.println(is);*/
    }
}

2.Spring 基于 XML 的 IOC 细节[掌握]

2.1 IoC(控制反转转-Inversion Of Control) 的概念和作用

通过 Spring 提供的 IoC 容器，可以将对象间的依赖关系交由 Spring 进行控制，避免硬编码所造成的过度程序耦合。（用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用）。耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。 **工厂模式解耦：**在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。那么，这个读取配置文件，创建和获取三层对象的类就是工厂。 以前我们在获取对象时，都是采用 new 的方式。是主动的。现在：我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。这种被动接收的方式获取对象的思想就是控制反转，它是 spring 框架的核心之一。

spring 中工厂的类结构图

在这里插入图片描述

BeanFactory 和 ApplicationContext 的区别

BeanFactory 才是 Spring 容器中的顶层接口。ApplicationContext 是它的子接口。
BeanFactory 和 ApplicationContext 的区别：
创建对象的时间点不一样。
ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。
BeanFactory：什么使用什么时候创建对象。

ApplicationContext 接口的实现类

ClassPathXmlApplicationContext：它是从类的根路径下加载配置文件 推荐使用这种
FileSystemXmlApplicationContext：它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
AnnotationConfigApplicationContext:当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解

2.2 bean 标签和管理对象细节

实例化 Bean对象 的三种方式

第一种方式：使用默认无参构造函数
在默认情况下：它会根据默认无参构造函数来创建类对象。如果 bean 中没有默认无参构造函数，将会创建失败。

第二种方式：spring 管理实例工厂-使用实例工厂的方法创建对象 （模拟一个工厂类，这个类可能是存在于jar中,我们无法通过修改源码的方式来提供默认构造函数）

/**
* 模拟一个实例工厂，创建业务层实现类
* 此工厂创建对象，必须现有工厂实例对象，再调用方法
*/
public class InstanceFactory {
   
public IAccountService createAccountService(){
   
		return new AccountServiceImpl();
}
}
<!-- 此种方式是：
先把工厂的创建交给 spring 来管理。
然后在使用工厂的 bean 来调用里面的方法createAccountService()来获取我们真正需要的AccountServiceImpl对象
factory-bean 属性：用于指定实例工厂 bean 的 id。
factory-method 属性：用于指定实例工厂中创建对象的方法。
-->
<!--所以需要书写两个bean -->
<bean id="instancFactory" class="com.itheima.factory.InstanceFactory"></bean>
<bean id="accountService"  factory-bean="instancFactory"  factory-method="createAccountService"></bean>

第三种方式：spring 管理静态工厂-使用静态工厂的方法创建对象（模拟一个工厂类，这个类可能是存在于jar中,我们无法通过修改源码的方式来提供默认构造函数）
/**

  • 模拟一个静态工厂，创建业务层实现类
    */
    public class StaticFactory {
    public static IAccountService createAccountService(){
    return new AccountServiceImpl();
    }
    }

bean 的作用范围–是对对象而言的

scope：指定对象的作用范围。
* singleton :默认值，单例的.
* prototype :多例的.
* request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
* session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
* global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session.

bean 的生命周期

单例对象：scope=“singleton”
一个应用只有一个对象的实例。它的作用范围就是整个引用。
生命周期：
对象出生：当应用加载，创建容器时，对象就被创建了。
对象活着：只要容器在，对象一直活着。
对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
多例对象：scope=“prototype”
每次访问对象时，都会重新创建对象实例。
生命周期：
对象出生：当使用对象时，创建新的对象实例。
对象活着：只要对象在使用中，就一直活着。
对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

2.3.spring 的依赖注入数据，它是 spring 框架核心 ioc 的具体实现

IOC的作用：降低程序间的耦合/依赖关系,但依赖关系的管理，都交给spring来维护，在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明。那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。
依赖关系的维护：
就称之为依赖注入。
依赖注入：
能注入的数据：有三类
基本类型和String
其他bean类型（在配置文件中或者注解配置过的bean）
复杂类型/集合类型
注入的方式：有三种
第一种：使用构造函数提供
第二种：使用set方法提供
第三种：使用注解提供（明天的内容）

构造函数注入 —不推荐

1.创建一个类，里面写上构造函数

package inject.service.impl;
import inject.service.IAccountService;
import java.util.Date;

/**
 * 账户的业务层实现类，用于构造函数注入，这里假设AccountServiceImpl类的字段是不经常变化的，
 * 因为要在xml文件中输入value值，频繁修改是不想要的，但这样写的目的主要是演示注入基本类型，
 * String和其他bean类型
 */
public class AccountServiceImpl implements IAccountService {
   
    private String name;//字符串类型
    private Integer age;//基本类型
    private Date birthday;//Bean类型

    public AccountServiceImpl(String name,Integer age,Date birthday){
   
        this.name=name;
        this.age=age;
        this.birthday=birthday;
    }

    public void  saveAccount(){
   
        System.out.println("service中的saveAccount方法执行了..."+name+","+age+","+birthday);
    }
}

2.配置文件
优势： 在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
弊端 改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。

<!--1.构造函数注入
    使用的标签:constructor-arg
        标签出现的位置：bean标签的内部
        标签中的属性
            type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
            index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
            name：用于指定给构造函数中指定名称的参数赋值        常用的
            =============以上三个都是用于指定给构造函数中哪个参数赋值===============================
            value：用于提供基本类型和String类型的数据
            ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象(比如自己配置的日期对象) -->
    <bean id="accountService" class="inject.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="研究生"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>
    <!--配置一个日期对象-->
    <bean id="now" class="java.util.Date"></bean>

3.测试类

/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {
   
    /**
     * 获取spring的ioc核心容器，并根据id获取对象
     * @param args
     */

    public static void main(String[] args) {
   
        //采用ApplicationContext创建对象，也是演示ApplicationContext创建对象的过程
        //1.获取核心容器对象
        ApplicationContext ac=new ClassPathXmlApplicationContext("beanInject4.xml");
//        ApplicationContext ac=new FileSystemXmlApplicationContext("F:\\springFrame\\src\\main\\resources\\bean.xml");

        //2.1 构造函数注入，根据id获取Bean对象
       IAccountService is=(IAccountService)ac.getBean("accountService");//把object对象，强转成IAccountService对象
        is.saveAccount();
    }
}
set方法注入

1.创建类，用于测试set方法，这里不需要写get方法

package inject.service.impl;
import inject.service.IAccountService;
import java.util.Date;
/**
 * 账户的业务层实现类，用于set方法注入，不需要写get
 */
public class AccountServiceImpl2 implements IAccountService {
   
    private String name;//字符串类型
    private Integer age;//基本类型
    private Date birthday;//Bean类型

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

    public void setAge(Integer age) {
   
        this.age = age;
    }

    public void setBirthday(Date birthday) {
   
        this.birthday = birthday;
    }

    public void  saveAccount(){
   
        System.out.println("service中的saveAccount方法执行了..."+name+","+age+","+birthday);
    }
}

2.配置文件

<!-- 2.set方法注入     更常用的方式
       涉及的标签：property
       出现的位置：bean标签的内部
       标签的属性
           name：用于指定注入时所调用的set方法名称
           value：用于提供基本类型和String类型的数据
           ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
       优势：
           创建对象时没有明确的限制，可以直接使用默认构造函数
       弊端：
           如果有某个成员必须有值，则获取对象是有可能set方法没有执行。
   -->
    <bean id="accountService2" class="inject.service.impl.AccountServiceImpl2">
        <property name="name" value="兰亭序"></property>
        <property name="age" value="21"></property>
        <property name="birthday" ref="now"></property>
    </bean>
    <!--配置一个日期对象-->
    <bean id="now" class="java.util.Date"></bean>

3.测试类 --模拟一个表现层，用于调用业务层

public class Client {
   
    /**
     * 获取spring的ioc核心容器，并根据id获取对象
     * @param args
     */
    public static void main(String[] args) {
   
        //采用ApplicationContext创建对象，也是演示ApplicationContext创建对象的过程
        //1.获取核心容器对象
        ApplicationContext ac=new ClassPathXmlApplicationContext("beanInject4.xml");
//        ApplicationContext ac=new FileSystemXmlApplicationContext("F:\\springFrame\\src\\main\\resources\\bean.xml");

        //2.2 set注入
        IAccountService is2=(IAccountService)ac.getBean("accountService2");//把object对象，强转成IAccountService对象
        is2.saveAccount();
复杂数据类型的set方法注入

1.创建类 --同理类的get方法也可以不写

package inject.service.impl;
import inject.service.IAccountService;
import java.util.*;
/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl3 implements IAccountService {
   
   private String[] str;
   private List<String> list;
   private Set<String>  set;
   private Map<String,String> map;
   private Properties prop;

    public String[] getStr() {
   
        return str;
    }

    public void setStr(String[] str) {
   
        this.str = str;
    }

    public List<String> getList() {
   
        return list;
    }

    public void setList(List<String> list) {
   
        this.list = list;
    }

    public Set<String> getSet() {
   
        return set;
    }

    public void setSet(Set<String> set) {
   
        this.set = set;
    }

    public Map<String, String> getMap() {
   
        return map;
    }

    public void setMap(Map<String, String> map) {
   
        this.map = map;
    }

    public Properties getProp() {
   
        return prop;
    }

    public void setProp(Properties prop) {
   
        this.prop = prop;
    }

    public void  saveAccount(){
   
        System.out.println(Arrays.toString(str));
        System.out.println(list);
        System.out.println(set);
        System.out.println(map);
        System.out.println(prop);
    }
}

2.配置文件

<!-- 复杂类型的注入/集合类型的注入
        用于给List结构集合注入的标签：
            list array set
        用于个Map结构集合注入的标签:
            map  props
        结构相同，标签可以互换
    -->
    <bean id="accountService3" class="inject.service.impl.AccountServiceImpl3">
        <property name="str">
            <array>
                <value>研究生</value>
                <value>兰亭序</value>
                <value>潘九弟</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>研究生</value>
                <value>兰亭序</value>
                <value>潘九弟</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>研究生</value>
                <value>兰亭序</value>
                <value>潘九弟</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="a" value="研究生"></entry>
                <entry key="b" >
                    <value>兰亭序</value>
                </entry>
                <entry key="c" value="潘九弟"></entry>
            </map>
        </property>
        <property name="prop">
            <props>
                <prop key="a">研究生</prop>
                <prop key="b">兰亭序</prop>
                <prop key="c">潘九弟</prop>
            </props>
        </property>
    </bean>

3.测试类跟上面的一样，只是全限定行名变了

3.基于注解的Ioc配置

曾经xml的配置：
 * <bean id="accountServive" class="ioc_xml.service.impl.AccountServiceImpl"></bean>
 *
 *用于创建对象的注解
*  *      他们的作用就和在XML配置文件中编写一个<bean>标签实现的功能是一样的
*  *      Component:
*  *          作用：用于把当前类对象存入spring容器中
*  *          属性：
*  *              value：用于指定bean的id(比如:设置了@Component(value = "accountServiceImpl")，那么在ac.getBean()创建bean对象时，可以根据我们设置的id名来获取，ac.getBean("accountServiceImpl"))。
*                      当我们不写时，它的默认值是当前类名，且首字母改小写。
*  *
 *        Controller：一般用在表现层
*  *      Service：一般用在业务层
*  *      Repository：一般用在持久层
*  *      以上三个注解他们的作用和属性与Component是一模一样。
*  *      他们三个是spring框架为我们提供明确的三层框架使用的注解，使我们的三层对象更加清晰
 *
 *   用于注入数据的注解
 *  *      他们的作用就和在xml配置文件中的bean标签中写一个<property>标签的作用是一样的
 *  *      Autowired:
 *  *          作用：自动按照类型注入。只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功
 *  *                如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错。
 *  *                如果Ioc容器中有多个类型匹配时：
 *  *          出现位置：
 *  *              可以是变量上，也可以是方法上
 *  *          细节：
 *  *              在使用注解注入时，set方法就不是必须的了。
 *  *      Qualifier:
 *  *          作用：在按照类中注入的基础之上再按照名称注入。它在给类成员注入时不能单独使用。但是在给方法参数注入时可以（见ioc_annotationcaseWithoutXml的JdbcConfiguration）
 *  *          属性：
 *  *              value：用于指定注入bean的id。
 *  *      Resource
 *  *          作用：直接按照bean的id注入。它可以独立使用
 *  *          属性：
 *  *              name：用于指定bean的id。
 *  *      以上三个注入都只能注入其他bean类型的数据，而基本类型和String类型无法使用上述注解实现。
 *  *      另外，集合类型的注入只能通过XML来实现。
 *  *
 *  *      Value
 *  *          作用：用于注入基本类型和String类型的数据
 *  *          属性：
 *  *              value：用于指定数据的值。它可以使用spring中SpEL(也就是spring的el表达式）
 *  *                      SpEL的写法：${
   表达式}
 *  *用于改变作用范围的注解
 *  *      他们的作用就和在bean标签中使用scope属性实现的功能是一样的
 *  *      Scope
 *  *          作用：用于指定bean的作用范围
 *  *          属性：
 *  *              value：指定范围的取值。常用取值：singleton prototype
 *  *
 *  * 和生命周期相关的注解 了解
 *  *      他们的作用就和在bean标签中使用init-method和destroy-methode的作用是一样的
 *  *      PreDestroy
 *  *          作用：用于指定销毁方法
 *  *      PostConstruct
 *  *          作用：用于指定初始化方法

这里有一部很重要的操作： 告知spring在创建容器时要扫描的包，当扫描这个包时，就会扫描包及其子包所有类的注解，配置所需要
的标签不在beans的约束中，而是一个名称为context名称空间和约束中。所以xml配置需要多加一个context约束以实现注解配置

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
    <!--告知spring在创建容器时要扫描的包，当扫描这个包时，就会扫描包及其子包所有类的注解，配置所需要
    的标签不在beans的约束中，而是一个名称为context名称空间和约束中-->
    <context:component-scan base-package="ioc_annotation5"/>
</beans>

3.1 通过对象注解获取对象 Component，Controller， Service， Repository

1.创建service类,记得加注解@Component，或@Service

package ioc_annotation5_1.service.impl;
import ioc_annotation5_1.dao.IAccountDao;
import ioc_annotation5_1.service.IAccountService;
import org.springframework.stereotype.Component;

@Component //等同与下面的Service注解
//@Component(value = "accountServiceImpl")  //只有value一个属性，也是可以不写的
public class AccountServiceImpl implements IAccountService {
   
    private IAccountDao accountDao;

    public AccountServiceImpl(){
   
        System.out.println("AccountServiceImpl对象被创建。。。");
    }

    public void  saveAccount(){
   
        accountDao.saveAccount();
    }
}

2.创建持久层类

package ioc_annotation5_1.dao.impl;

import ioc_annotation5_1.dao.IAccountDao;

/**
 * 账户的持久层实现类
 */
public class AccountDaoImpl implements IAccountDao {
   

    public  void saveAccount(){
   
        System.out.println("AccountDaoImpl1保存了账户");
    }
}

3.配置文件

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

    <!--告知spring在创建容器时要扫描的包，当扫描这个包时，就会扫描包及其子包所有类的注解，配置所需要
    的标签不在beans的约束中，而是一个名称为context名称空间和约束中-->
    <context:component-scan base-package="ioc_annotation5_1"/>
</beans>

4.创建测试类类

package ioc_annotation5_1.ui;
import ioc_annotation5_1.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {
   
    /**
     * 获取spring的ioc核心容器，并根据id获取对象
     * @param args
     */
    public static void main(String[] args) {
   
        //1.获取核心容器对象
        ApplicationContext ac=new ClassPathXmlApplicationContext("beanAnnotation.xml");
        //2.根据id获取Bean对象
        IAccountService is1=(IAccountService)ac.getBean("accountServiceImpl");//把object对象，强转成IAccountService对象
        System.out.println(is1);
    }
}

同理AccountDaoImpl对象也是同样方式获取
只需要在AccountDaoImpl加上@Repository注解即可

package ioc_annotation5_1.dao.impl;
import
最低0.47元/天 解锁文章
yandajiangjun
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
SSM使用jar包
06-14
SSM开发相关的jar包，使用的是架构是Struts、SpringMVC和mybatis（Mysql）
学习笔记：SSM工程各个文件夹大概作用
qq_42422583的博客
09-26 2442
参考了红黑联盟的大佬文章留下笔记用来记忆 src 根目录，没什么好说的，下面有main和test。 main 主要目录，可以放java代码和一些资源文件。 java 存放我们的java代码，这个文件夹要使用Build Path -&amp;gt; Use as Source Folder，这样看包结构会方便很多，新建的包就相当于在这里新建文件夹咯。 resources 存放资源文件，譬如各种的spring...
SSM框架各种配置文件及作用
lls_663的博客
07-04 709
SSM框架 1.各种配置文件及作用 1.pom.xml配置文件 说明：自动导入各种包和插件 <dependencies> <!--单元测试包--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.1
SSM框架原理,作用及使用方法
m0_65467786的博客
02-19 234
Mybatis：mybatis是对jdbc的封装，它让数据库底层操作变的透明。Spring：我们平时开发接触最多的估计就是IOC容器，它可以装载bean（也就是我们Java中的类，当然也包括service dao里面的），有了这个机制，我们就不用在每次使用这个类的时候为它初始化，很少看到关键字new。SSM框架是spring MVC ，spring和mybatis框架的整合，是标准的MVC模式，将整个系统划分为表现层，controller层，service层，DAO层四层。5.视图负责将结果显示到客户端。
SSM简单的使用
weixin_52192654的博客
04-20 428
SSM简单的使用(增删改查) 一、创建数据库表 #用户基本信息表 create table ssm_user( user_id int primary key auto_increment, user_name varchar(20), user_age int, user_address varchar(30) ); 二、创建项目，完善结构 三、导入依赖 <!-- https://mvnrepository.com/artifact/org.springfra...
SSM的简单使用
X3282727844的博客
07-17 747
SSM的简单使用
基于SSM使用idea构建的旅游网站---毕业设计.zip
07-08
基于ssm写的系统（含数据库文件） 语言：java 框架：ssm 数据库：mysql
SSM整合使用
09-11
Spring SpringMVC mybatis 的整合使用，mybatis来实现数据的读取操作，Spring控制反转，SpringMVC 控制页面
solr ssm java
12-22
自己弄的一个maven项目 框架ssm 改改配置就能用 搭建文档我已经加到了压缩包 有不懂的可以问 windows下搭建的solr 跟linux步骤差不多
基于SSM使用ueditor编辑框文本、图片上传功能实现
11-07
基于SSM简单使用ueditor编辑框文本、图片上传功能，基础
ssm+maven使用详细教程
11-01
内有ssm及maven额度详细使用过程，标记的都很清晰，重要部分已有不同颜色字体标注
ssm+maven+tomcat框架整合（拒绝花里胡哨的配置）
05-08
下载下来，项目名称想改可以改（记得还要改pom里的项目名称），不改也没事，框架里面有普通的查询功能，不要也可以删除。我用的tomcat8+jdk1.8
ssm简单使用
silversoldier的博客
05-16 1781
前言在Spring4+SpringMVC+mybatis整合中，我们已经实现了ssm的整合以及显示商品列表信息，接下来让我们来添加商品修改功能。编写Service接口我们要根据定义根据id找到商品信息的接口，和修改商品信息同步更新到数据库的接口在Service包下为itemsService新增两个接口package service; import po.ItemCustom; import po...
什么是ssm？如何使用ssm进行后端开发
热门推荐
weixin_57663206的博客
11-14 2万+
Spring注解开发
SSM整合，手把手教程，详解思路讲解
liyingjie2001的博客
05-17 1万+
SSM（Spring+SpringMVC+MyBatis）框架集由Spring、MyBatis两个开源框架整合而成（SpringMVC是Spring中的部分内容），常作为数据源较简单的web项目的框架。虽然现在后端主流开发API的框架是springboot，但ssm的学习依然重要，也是springboot的基石。 很多人说ssm配置起来太麻烦了，不如springboot，看完我这篇，让你在ssm阶段像SpringBoot一样快速搭建，大大提高开发效率 项目搭建 一，工程创建 1.新建Ma
【SSM框架 三】SpringMVC
daban2008的专栏
12-04 262
SpringMVC
ssm使用流程总结（简要）
Xlaoer的博客
05-22 1190
目录一、mybatis框架1.设计表2.根据表创建pojo实体类3.根据业务需要尽可能全地编写Dao层 （复杂点）BookMapper接口BookMapper.xml4.配置mybatis核心配置文件mybatis-config.xml5.原来要写SqlSession这样的工具类，然后放mapper进去，达到操作数据库spring-dao.xml二、Spring框架1.编写Service层，调用dao层接口，达到满足实际业务的service类BookService接口BookServiceImpl.jav
SSM框架——干净详细的整合学习教程（Spring+SpringMVC+MyBatis）
麦克劳林
11-25 812
一、SpringMVC概述 熟悉MVC的同学都知道，MVC即model（模型）、view（视图）、controller（控制），用一种业务逻辑，数据，界面显示分离的方式使得开发更加的便捷高效，具有低耦合，高重用性，可维护性等优点。 因此，SpringMVC分为用户界面层（view）、web层（controller）、领域模型层（model）。 用户界面层：有两个重要的接口 org.springfr...
【SSM】如何在IDEA配置tomcat启动项目
阿杰
01-18 3969
SSM的项目如果没有配置tomcat插件，就只能使用tomcat启动了
ssm 使用quarz
最新发布
07-14
在 SSM（Spring + Spring MVC + MyBatis）框架中使用 Quartz 是很常见的。Quartz 可以与 SSM 框架集成，用于在后台执行定任务。以下是在 SSM 中使用 Quartz 的基本步骤： 1. 添加依赖：在项目的 pom.xml 文件中添加...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值