SSM框架

最新推荐文章于 2022-10-14 15:04:54 发布
最新推荐文章于 2022-10-14 15:04:54 发布
阅读量261 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46804568/article/details/119189535
版权

SSM框架

Mybatis框架

1、依赖

mybatis

<dependency>
	<groupId>org.mybatis</groupId>
	<artifactId>mybatis</artifactId>
	<version>3.5.3</version>
</dependency>

连接数据库

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>8.0.19</version>
</dependency>

2、配置文件

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
		PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
		"http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--各个标签位置都是固定的-->
<configuration>
	<!-- 引用数据源配置文件 properties只能放在最上面-->
	<properties resource="db.properties"/>

	<settings>
		<setting name="logImpl" value="LOG4j"/>
		<setting name="mapUnderscoreToCamelCase" value="true"/>	<!--开启驼峰命名自动映射-->
		<!--显示的开启缓存，默认为开启-->
		<setting name="cacheEnabled" value="true"/>
	</settings>

	<typeAliases>
		<package name="com.tian.pojo"/>
	</typeAliases>

	<!--可以配置多套环境，但是每次只能选择一个环境 default用来选择环境-->
	<environments default="development">
		<environment id="development">
			<!--transactionManager ：事务管理器-->
			<transactionManager type="JDBC" />
			<!--dataSource ：数据源 配置数据库连接信息 -->
			<dataSource type="POOLED">
				<!-- 下面的value属性值，从文件db.properties里引用而来 -->
				<property name="driver" value="${driver}" />
				<property name="url" value="${url}" />
				<property name="username" value="${username}" />
				<property name="password" value="${password}" />
			</dataSource>
		</environment>
	</environments>
</configuration>

db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&characterEncoding=utf-8
username=root
password=root

3、工具类

package com.tian.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

//mybatis工具类
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            //使用mybatis第一步：获取SqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSession getSqlSession() {
        //设置自动提交
        return sqlSessionFactory.openSession(true);
    }
}

4、实体类

pojo

package com.tian.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    private int id;
    private String name;
    private String pwd;
}

需要添加lombok插件和依赖

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.20</version>
    <scope>provided</scope>
</dependency>

mapper层

接口：操作数据库

package com.tian.dao;

import com.tian.pojo.User;
import org.apache.ibatis.annotations.Param;

public interface UserMapper {

    //根据id查询用户
    User queryById(@Param("id") int id);
}

映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.tian.dao.UserMapper">

    <select id="queryById" resultType="User" parameterType="_int">
        select * from user where id = #{id}
    </select>
</mapper>

5、注册Mapper

<!-- 注册userMapper.xml文件 
     每一个Mapper.xml都要在mybatis核心配置文件中注册-->
<mappers>
	<mapper class="com.tian.dao.UserMapper"/>
	<!--<mapper resource="com/tian/dao/UserMapper.xml"/>-->
</mappers>

6、测试

import com.tian.dao.UserMapper;
import com.tian.pojo.User;
import com.tian.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class MyTest {

    @Test
    public void test () {
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User user = mapper.queryById(1);
        System.out.println(user);
        sqlSession.close();
    }
}

===============

7、增删改查

<!--查询语句，id=对应接口中方法的名称-->
<select id="getUserList" resultType="User" >
    select * from mybatis.user
</select>

<select id="getUserById" parameterType="int" resultType="User">
    select * from mybatis.user
        where id = #{id}
</select>

<!--插入语句-->
<insert id="insertUser" parameterType="User">
    insert into mybatis.user
        values(#{id}, #{name}, #{pwd})
</insert>

<!--修改语句-->
<update id="updateUser" parameterType="User">
    update mybatis.user set name=#{name}, pwd=#{pwd}
        where id = #{id};
</update>

<!--删除语句-->
<delete id="deleteUser" parameterType="int">
    delete from mybatis.user
        where id = #{id}
</delete>

8、结果集映射

当数据库的列名和类的属性名不一致时，需要通过建立映射关系使得它俩对应上。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!--namespace=绑定一个对应的Dao/Mapper接口-->
<mapper namespace="com.tian.dao.UserMapper">

    <!--结果集映射-->
    <resultMap id="UserMap" type="User">
        <!--column对应数据库中的字段，property对应实体类中的属性-->
        <id column="id" property="id"/>
        <id column="name" property="name"/>
        <id column="pwd" property="password"/>
    </resultMap>

    <select id="getUserById" parameterType="int" resultMap="UserMap">
        select * from mybatis.user
            where id = #{id}
    </select>

    <select id="getUserByLimit" resultMap="UserMap" parameterType="map">
        select *  from mybatis.user limit #{startIndex},#{pageSize}
    </select>
</mapper>

9、使用注解

@Param注解

//方法存在多个参数，所有参数前面必须加上@Param("参数名称")注解，取值以注解中取得名称为主
@Select("select * from mybatis.user where id=#{id}")
User getUserByID(@Param("id") int id);

package com.tian.dao;

import com.tian.pojo.User;
import org.apache.ibatis.annotations.*;

import java.util.List;
import java.util.Map;

public interface UserMapper {

    @Select("select * from mybatis.user")
    List<User> getUsers();

    //方法存在多个参数，所有参数前面必须加上@Param("参数名称")注解，取值以注解中取得名称为主
    @Select("select * from mybatis.user where id=#{id}")
    User getUserByID(@Param("id") int id);

    @Insert("insert into user values(#{id},#{name},#{pwd})")
    int addUser(User user);

    @Update("update user set name=#{name},pwd=#{pwd} where id = #{id}")
    int updateUser(User user);

    @Delete("delete from user where id=#{id}")
    int deleteUser(int id);
}

10、多对一

多个学生对应一个老师

Student

package com.tian.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
    private int id;
    private String name;
    //学生需要关联一个老师
    private Teacher teacher;
}

Teacher

package com.tian.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Teacher {
    private int id;
    private String name;
}

StudentMapper.java

package com.tian.dao;

import com.tian.pojo.Student;

import java.util.List;

public interface StudentMapper {

    List<Student> getStudent();

    List<Student> getStudent2();
}

TeacherMapper.java

package com.tian.dao;

import com.tian.pojo.Teacher;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

public interface TeacherMapper {

    @Select("select * from mybatis.teacher where id=#{id}")
    Teacher getTeacher(@Param("id") int id);
}

StudentMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.tian.dao.StudentMapper">

    <!--按照结果嵌套处理-->
    <select id="getStudent2" resultMap="StudentTeacher2">
        select s.id sid,s.name sname,t.name tname from student s,teacher t
        where s.tid=t.id
    </select>

    <resultMap id="StudentTeacher2" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="Teacher">
            <result property="name" column="tname"/>
        </association>
    </resultMap>




    <!--===========================================-->

    <!--通过查询嵌套处理-->
    <select id="getStudent" resultMap="StudentTeacher">
        select * from student
    </select>
    <resultMap id="StudentTeacher" type="Student">
        <id property="id" column="id"/>
        <id property="name" column="name"/>
        <!--复杂的属性需要单独处理
            对象：association
            集合：collection
        -->
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>

    </resultMap>

    <select id="getTeacher" resultType="Teacher">
        select * from teacher where id=#{id}
    </select>
</mapper>

TeacherMapper.xml

不做处理

测试

package com.tian.dao;

import com.tian.pojo.Student;
import com.tian.pojo.Teacher;
import com.tian.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class MyTest {

    @org.junit.Test
    public void test() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.getTeacher(1);

        System.out.println(teacher);

        sqlSession.close();

    }

    //通过查询嵌套处理
    @Test
    public void test2() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> student = mapper.getStudent();
        for (Student student1 : student) {
            System.out.println(student1);
        }

        sqlSession.close();
    }

    //按照结果嵌套处理
    @Test
    public void test3() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> student2 = mapper.getStudent2();
        for (Student student : student2) {
            System.out.println(student);
        }

        sqlSession.close();
    }
}

11、一对多

一个老师有多个学生

Student

package com.tian.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student {
    private int id;
    private String name;
    private int tid;
}

Teacher

package com.tian.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Teacher {
    private int id;
    private String name;

    //一个老师拥有多个学生
    private List<Student> students;
}

StudentMapper.java

不做处理

TeacherMapper.java

package com.tian.dao;

import com.tian.pojo.Teacher;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface TeacherMapper {
//
//    //获取所有老师信息
//    List<Teacher> getTeacher();

    //获取指定老师下的所有学生信息
    Teacher getTeacher(@Param("tid") int id);
    Teacher getTeacher2(@Param("tid") int id);
}

TeacherMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.tian.dao.TeacherMapper">
    <!--按照结果嵌套查询-->
    <select id="getTeacher" resultMap="TeacherStudent">
        select s.id sid,s.name sname,t.id tid,t.name tname from student s,teacher t
        where s.tid = t.id and t.id = #{tid}
    </select>
    
    <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <!--对象：association 集合：collection
            javaType="" 指定属性的类型
            集合中的泛型信息，我们使用ofType获取
        -->
        <collection property="students" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="tname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

    <!--============================================================-->

    <!---->
    <select id="getTeacher2" resultMap="TeacherStudent2">
        select * from teacher where id = #{tid}
    </select>
    <resultMap id="TeacherStudent2" type="Teacher">
        <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/>
    </resultMap>

    <select id="getStudentByTeacherId" resultType="Student">
        select * from student where tid = #{tid}
    </select>
</mapper>

测试

package com.tian.dao;

import com.tian.pojo.Student;
import com.tian.pojo.Teacher;
import com.tian.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class TeacherTest {

    @Test
    public void test() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);

        Teacher teacher = mapper.getTeacher(1);
        System.out.println(teacher);

        sqlSession.close();
    }

    @Test
    public void test2() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);

        Teacher teacher2 = mapper.getTeacher2(1);
        System.out.println(teacher2);

        sqlSession.close();
    }

}

Spring框架

1、依赖

spring

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

jdbc

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

2、配置文件

applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

3、实体类

package com.tian.pojo;

public class Hello {
    private String str;

    public String getStr() {
        return str;
    }

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

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

4、使用spring管理对象

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

    <!--使用spring来创建对象，bean表示一个对象

        id = 变量名
        class = new 的对象
        property 相当于给对象中的属性设置一个值，本质是set注入
    -->
    <bean id="hello" class="com.tian.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>

</beans>

5、测试

import com.tian.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    @Test
    public void test() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        User user = context.getBean("user", User.class);

        System.out.println(user);
    }
}

=================

6、IOC

在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。

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

    <!--使用有参构造-->
    <!--第一种，下标赋值-->
<!--    <bean id="user" class="com.tian.pojo.User">-->
<!--        <constructor-arg index="0" value="Spring学习"/>-->
<!--    </bean>-->

    <!--第二种，使用类型创建，不建议使用-->
<!--    <bean id="user" class="com.tian.pojo.User">-->
<!--        <constructor-arg type="java.lang.String" value="Spring学习"/>-->
<!--    </bean>-->

    <!--第三种，直接通过参数名来设置-->
    <bean id="user" class="com.tian.pojo.User">
        <constructor-arg name="name" value="Spring学习"/>
    </bean>

</beans>

7、DI

Student.java

package com.tian.pojo;

import java.util.*;

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbies;
    private Map<String,String> cards;
    private Set<String> games;
    private String wife;
    private Properties info;

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbies() {
        return hobbies;
    }

    public void setHobbies(List<String> hobbies) {
        this.hobbies = hobbies;
    }

    public Map<String, String> getCards() {
        return cards;
    }

    public void setCards(Map<String, String> cards) {
        this.cards = cards;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address +
                ", books=" + Arrays.toString(books) +
                ", hobbies=" + hobbies +
                ", cards=" + cards +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

依赖注入

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

    <bean id="student" class="com.tian.pojo.Student">
        <!--第一种，普通值注入-->
        <property name="name" value="Java-Spring"/>
        <!--第二种，bean注入，使用ref-->
        <property name="address" ref="address"/>
        <!--第三种，数组注入-->
        <property name="books">
            <array>
                <value>红楼梦</value>
                <value>西游记</value>
                <value>三国演义</value>
                <value>水浒传</value>
            </array>
        </property>
        <!--第四种，list注入-->
        <property name="hobbies">
            <list>
                <value>听歌</value>
                <value>看电影</value>
            </list>
        </property>
        <!--第五种，Map注入-->
        <property name="cards">
            <map>
                <entry key="学生卡" value="123456"/>
                <entry key="银行卡" value="147852"/>
            </map>
        </property>
        <!--第六种，Set集合注入-->
        <property name="games">
            <set>
                <value>王者荣耀</value>
                <value>超级玛丽</value>
            </set>
        </property>
        <!--第七种，properti注入-->
        <property name="info">
            <props>
                <prop key="学号">123456789</prop>
                <prop key="性别">男</prop>
            </props>
        </property>
        <!--第八种，空值注入-->
        <property name="wife">
            <null/>
        </property>
    </bean>

</beans>

8、自动装配

  • @Autowired是按类型自动转配的，不支持id匹配。

    将User中的set方法去掉，加入@Autowired注解。

    加上@Qualifier则可以根据byName的方式自动装配，其中@Qualifier不能单独使用。

  • @Resource如有指定的name属性，先按该属性进行byName方式查找装配；其次再进行默认的byName方式进行装配；如果以上都不成功，则按byType的方式自动装配。都不成功，则报异常。

@Autowired与@Resource异同：

  • @Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。

  • @Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用。

  • @Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。 当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

  • 它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先byName。

package com.tian.pojo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;

public class People {
    @Autowired
    private Dog dog;
    @Autowired
    @Qualifier(value = "cat")
    private Cat cat;
    private String name;

    public Dog getDog() {
        return dog;
    }

    public Cat getCat() {
        return cat;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "People{" +
                "dog=" + dog +
                ", cat=" + cat +
                ", name='" + name + '\'' +
                '}';
    }
}

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

<context:annotation-config/>
    <!--使用autowired我们可以不写set方法，前提是你这个自动装配的属性在IOC（spring）容器中存在，且符合名字要求-->

    <bean id="dog" class="com.tian.pojo.Dog"/>
    <bean id="cat" class="com.tian.pojo.Cat"/>

    <!--
        byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid
        byType：会自动在容器上下文中查找，和自己对象属性类型相同的beanid，必须保证对象全局唯一
    -->
    <bean id="people" class="com.tian.pojo.People"/>
</beans>

9、使用注解

package com.tian.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

//等价于  <bean id="user" class="com.tian.pojo.User"/>
//@Component 组件
@Component
public class User {

    //等价于  <property name="name" value="陈会天"/>
    @Value("陈会天")
    public String name;

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

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

    <!--指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.tian"/>
    <!--注解驱动-->
    <context:annotation-config/>

</beans>

10、JavaConfig

package com.tian.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

//这里这个注解的意思就是说明这个类被Spring接管了，注册到了容器中
@Component
public class User {

    private String name;

    public String getName() {
        return name;
    }

    @Value("陈会天") //属性注入值
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

package com.tian.config;

import com.tian.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/*
这个也会被Spring容器托管，注册到容器中，因为它本身就是一个@Component
@Configuration 代表这是一个配置类，就是我们之前所使用的beans.xml
 */
@Configuration
public class MyConfig {

    //注册一个bean，就相当于配置文件中的一个bean标签
    //这个方法的名字，就相当于bean标签中的id属性
    //这个方法的返回值，就相当于bean标签中的class属性
    @Bean
    public User getUser() {
        return new User();  //就是返回要注入到bean的对象
    }

}

11、AOP

UserServiceImpl.java

package com.tian.service;

public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("增加了一个用户");
    }

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

    @Override
    public void update() {
        System.out.println("修改了一个用户");
    }

    @Override
    public void select() {
        System.out.println("查询了一个用户");
    }
}

日志类

package com.tian.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Log implements MethodBeforeAdvice {

    /*
    method：要执行的目标对象的方法
    args：参数
    target：目标对象
    */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行" + target.getClass().getName());
    }
}

package com.tian.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {
    //returnValues：返回值
    @Override
    public void afterReturning(Object returnValues, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了" + method.getName() + "返回结果为：" + returnValues);
    }
}

DiyPointcut.java

package com.tian.diy;

public class DiyPointcut {

    public void before() {
        System.out.println("方法执行前");
    }

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

使用注解

AnnotationPointcut.java

package com.tian.diy;

//方式三：使用注解实现

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

//标注这个类是一个切面
@Aspect
public class AnnotationPointcut {

    @Before("execution(* com.tian.service.UserServiceImpl.*(..))")
    public void before() {
        System.out.println("-方法执行前-");
    }

    @After("execution(* com.tian.service.UserServiceImpl.*(..))")
    public void after() {
        System.out.println("-方法执行后-");
    }

}

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

    <!--注册bean-->
    <bean id="userService" class="com.tian.service.UserServiceImpl"/>
    <bean id="log" class="com.tian.log.Log"/>
    <bean id="afterLog" class="com.tian.log.AfterLog"/>

    <!--方式三：使用注解实现-->
    <bean id="annotationPointcut" class="com.tian.diy.AnnotationPointcut"/>
    <!--开启注解支持-->
    <aop:aspectj-autoproxy/>


    <!--方式一：使用原生spring api接口-->
    <!--配置aop：需要导入aop的约束-->
    <aop:config>
        <!--切入点：expression：表达式：execution()-->
        <aop:pointcut id="pointcut" expression="execution(* com.tian.service.UserServiceImpl.*(..))"/>

        <!--执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

    <!--方式二：自定义类-->
    <bean id="diy" class="com.tian.diy.DiyPointcut"/>

    <aop:config>
        <!--自定义切面，ref 要引用的类-->
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="pointcut" expression="execution(* com.tian.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="before" pointcut-ref="pointcut"/>
            <aop:after method="after" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>

</beans>

12、整合Mybatis

spring-dao整合mybatis的核心配置，保留的mybatis-config.xml里面进行mybatis一些其他方面的配置，最后的applicationContext将两个配置文件进行了整合，并且Mapper的装配在这里面进行，使得spring-dao中的代码最大程度上不需要修改，便于复用。

spring-dao.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"
       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
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--DataSource：使用spring的数据源替换mybatis的配置
    这里使用spring提供的jdbc-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC&amp;characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--绑定mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath*:com/tian/mapper/*.xml"/>
    </bean>

    <!--SqlSessionTemplate：就是我们使用的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入，因为他没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

</beans>

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
      PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
      "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--各个标签位置都是固定的-->
<configuration>

   <typeAliases>
      <package name="com.tian.pojo"/>
   </typeAliases>

</configuration>

applicationContext.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"
       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
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <import resource="spring-dao.xml"/>

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

    <bean id="userMapper2" class="com.tian.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

</beans>

Spring MVC框架

1、依赖

spring

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

servlet

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>servlet-api</artifactId>
    <version>2.5</version>
</dependency>
<!--jstl-->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

2、配置web.xml

Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。

Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。

<!--1、注册DispatcherServlet-->
<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!--关联一个springmvc的配置文件-->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:springmvc-servlet.xml</param-value>
    </init-param>
    <!--启动级别-->
    <load-on-startup>1</load-on-startup>
</servlet>

<!--/ 匹配所有的请求（不包括.jsp）-->
<!--/* 匹配所有的请求（包括.jsp）-->
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--添加处理映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--添加处理适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

    <!--视图解析器：DispatcherServlet给他的ModelAndView
        1、获取了ModelAndView的数据
        2、解析ModelAndView的视图名字
        3、拼接视图名字，找到对应的视图  前缀 + hello + 后缀 = /WEB-INF/jsp/hello.jsp
        4、将数据渲染到这个视图上
     -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

4、controller层

package com.tian.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

//注意：这里我们先导入Controller接口
public class HelloController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        //ModelAndView 模型和视图
        ModelAndView mv = new ModelAndView();

        //封装对象，放在modelAndView中。
        mv.addObject("msg", "HelloSpringMVC!");
        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello"); //   /WEB-INF/jsp/hello.jsp
        return mv;
    }
}

将自己的类交给SpringIOC容器，注册bean

<!--handler：根据请求找到该处理器-->
<bean id="/hello" class="com.tian.controller.HelloController"/>

5、使用注解

web.xml不变

5.1、配置文件

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

    <!--自动扫描包，让指定包下的注解生效，有IOC容器统一管理-->
    <context:component-scan base-package="com.tian.controller"/>

    <!--让Spring MVC不处理静态资源-->
    <mvc:default-servlet-handler/>

    <!--
    支持MVC注解驱动
        在spring一般采用@RequestMapping注解来完成映射关系
        要想使@RequestMapping注解生效
        必须向上下文中注册DefaultAnnotationHandlerMapping和一个
        AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入
    -->
    <mvc:annotation-driven/>

    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

5.2、controller层

package com.tian.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

//被这个注解的类中的所有方法，如果返回值是string，并且有具体页面可以跳转，那么就会被视图解析器解析
@Controller     //代表这个类会被spring接管
public class HelloController {
    @RequestMapping("/hello")	//相当于<bean id="/hello" class="com.tian.controller.HelloController"/>
    public String hello(Model model) {
        //封装数据
        model.addAttribute("msg", "Hello,SpringMVCAnnotation!");
        return "hello"; //会被视图解析器处理
    }
}

SSM整合

项目开发步骤

  • 前端页面和controller层交互，controller层调用service层，service层调用dao层，dao层调用数据库。
  • 先写dao层（接口和映射接口文件），再写service层（方法和dao层接口方法一致，实现类）
    最后写controller层。

====================================================

导入依赖

<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.20</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>

    <!--数据库驱动-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.19</version>
    </dependency>

    <!--数据库连接池 c3p0-->
    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.5.2</version>
    </dependency>

    <!--servlet JSP-->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.5</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.1</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>

    <!--mybatis-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.6</version>
    </dependency>

    <!--spring-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.7</version>
    </dependency>
</dependencies>

静态资源导出

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

1、Mybatis

1.1、配置文件

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <typeAliases>
        <package name="com.tian.pojo"/>
    </typeAliases>
    
    <mappers>
        <mapper class="com.tian.dao.BookMapper"/>
    </mappers>
</configuration>

database.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?userSSL=true&useUnicode=true&serverTimezone=GMT&characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

1.2、实体类

Books.java

package com.tian.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Books {
    private int bookID;
    private String bookName;
    private int bookCounts;
    private String detail;
}

1.3、dao层

dao层操作数据库

接口：BookMapper.java

package com.tian.dao;

import com.tian.pojo.Books;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface BookMapper {
    //增加一本书
    int addBook(Books books);

    //删除一本书
    int deleteBookById(@Param("bookID") int id);

    //更新一本书
    int updateBook(Books books);

    //查询一本书
    Books queryBookById(@Param("bookID") int id);

    //查询全部书
    List<Books> queryAllBook();

    //按照书名查询书籍信息
    Books queryBookByName(@Param("bookName") String bookName);
}

映射接口文件：BookMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tian.dao.BookMapper">

    <insert id="addBook" parameterType="Books">
        insert into ssmbuild.books(bookName,bookCounts,detail)
         values(#{bookName}, #{bookCounts}, #{detail});
    </insert>

    <delete id="deleteBookById" parameterType="_int">
        delete from ssmbuild.books
         where bookID=#{bookID};
    </delete>

    <update id="updateBook" parameterType="Books">
        update ssmbuild.books
         set bookName=#{bookName},bookCounts=#{bookCounts},detail=#{detail}
         where bookID=#{bookID};
    </update>

    <select id="queryBookById" parameterType="_int" resultType="Books">
        select * from ssmbuild.books
         where bookID = #{bookID};
    </select>

    <select id="queryAllBook" resultType="Books">
        select * from ssmbuild.books;
    </select>

    <select id="queryBookByName" resultType="Books">
        select * from ssmbuild.books
        where bookName=#{bookName}
    </select>
</mapper>

1.4、service层

service层调用dao层

BookService.java

package com.tian.service;

import com.tian.pojo.Books;

import java.util.List;

public interface BookService {
    //增加一本书
    int addBook(Books books);

    //删除一本书
    int deleteBookById(int id);

    //更新一本书
    int updateBook(Books books);

    //查询一本书
    Books queryBookById(int id);

    //查询全部书
    List<Books> queryAllBook();

    //按照书名查询书籍信息
    Books queryBookByName(String bookName);
}

实现类

BookServiceImpl.java

package com.tian.service;

import com.tian.dao.BookMapper;
import com.tian.pojo.Books;

import java.util.List;

public class BookServiceImpl implements BookService {
    //service调dao层
    private BookMapper bookMapper;

    public void setBookMapper(BookMapper bookMapper) {
        this.bookMapper = bookMapper;
    }

    @Override
    public int addBook(Books books) {
        return bookMapper.addBook(books);
    }

    @Override
    public int deleteBookById(int id) {
        return bookMapper.deleteBookById(id);
    }

    @Override
    public int updateBook(Books books) {
        return bookMapper.updateBook(books);
    }

    @Override
    public Books queryBookById(int id) {
        return bookMapper.queryBookById(id);
    }

    @Override
    public List<Books> queryAllBook() {
        return bookMapper.queryAllBook();
    }

    @Override
    public Books queryBookByName(String bookName) {
        return bookMapper.queryBookByName(bookName);
    }
}

2、spring

配置文件

2.1、整合dao层

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

    <!--1、关联数据库配置文件-->
    <context:property-placeholder location="classpath:database.properties"/>

    <!--2、连接池
        dbcp：半自动操作，不能自动连接
        c3p0：自动化操作（自动化的加载配置文件，并且可以自动设置到对象中）
        druid
    -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

        <!--c3p0连接池的私有属性-->
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>
        <!--关闭连接后不自动提交-->
        <property name="autoCommitOnClose" value="false"/>
        <!--获取连接超时时间-->
        <property name="checkoutTimeout" value="10000"/>
        <!--当获取连接失败重试次数-->
        <property name="acquireRetryAttempts" value="2"/>
    </bean>

    <!--3、sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!--绑定mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

    <!--4、配置dao接口扫描包，动态的实现了dao接口可注入到spring容器中-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--注入sqlSessionFactory-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--要扫描的dao包-->
        <property name="basePackage" value="com.tian.dao"/>
    </bean>
</beans>

2.2、整合service层

spring-service.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--1、扫描service下的包-->
    <context:component-scan base-package="com.tian.service"/>

    <!--2、将我们的所有业务类注入到spring，可以通过配置，或者注解实现（自动装配@autowired）-->
    <bean id="bookServiceImpl" class="com.tian.service.BookServiceImpl">
        <property name="bookMapper" ref="bookMapper"/>
    </bean>

    <!--3、声明式事务配置-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--结合aop实现事务的织入-->
    <!--配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--给那些方法配置事务-->
        <!--配置事务的传播特性：propagation-->
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!--配置事务切入-->
    <aop:config>
        <aop:pointcut id="txPointcut" expression="execution(* com.tian.dao.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
    </aop:config>
</beans>

3、spring MVC

3.1、配置文件

spring-mvc.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--1、注解驱动-->
    <mvc:annotation-driven/>

    <!--2、静态资源过滤-->
    <mvc:default-servlet-handler/>

    <!--3、扫描包：controller-->
    <context:component-scan base-package="com.tian.controller"/>

    <!--4、视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

</beans>

3.2、配置web.xml

<!--DispatcherServlet-->
<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

<!--乱码过滤-->
<filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

    <init-param>
        <param-name>encoding</param-name>
        <param-value>utf-8</param-value>
    </init-param>
</filter>

<filter-mapping>
    <filter-name>encodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

<!--session-->
<session-config>
    <session-timeout>15</session-timeout>
</session-config>
辛夷陵
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ssm框架项目功能点
weixin_43031438的博客
11-14 918
一，模糊查询，条件查询，分页 。 在mvc 层中 ，分页的赋值等，都写在service层，原因是在service层设置了事务，如果程序有错。service层具有回滚，但是controller层并不具备。 一个通用的pageUtil，可以对多个类和多个页面进行分页，pageUtil可以为被继承的方式来进行分页。在controller层中，获取参数也可以直接用pageUtil或者被继承的类来直接获取。...
SSM框架SSM框架SSM框架
05-15
SSM框架 SSM框架是一个基于JavaEE的开源框架，主要包括Spring、SpringMVC、MyBatis三个组件。下面对SSM框架的组件进行详细的解释： 1. Spring框架：Spring是一个轻量级的JavaEE框架，提供了一个通用的应用程序开发...
SSM框架的整合
qq_45174069的博客
05-20 397
由于Spring MVC是Spring框架中的一个模块，所以Spring MVC与Spring之间不存在整合的问题，只要引入相应JAR包就可以直接使用。 SSM框架整合图如下所示： 了解后，我们先开始准备框架所需的JAR包 我们要引入Spring与MyBatis整合所需要的JAR包，再加入Spring MVC的相关JAR包。 我们通过pom.xml中导入jar包 1.打开http://mvnrepository.com/ 2.搜索jar包 3.查看Maven pom.xml依赖语句，然后复制到你的项目po
SSM框架对MybatisUtils封装
qq_54407314的博客
10-14 127
SSM框架对MybatisUtils封装。
ssm框架搭建
qq_39081966的博客
04-18 297
SSM框架整合1、什么是SSM框架?SSM即SpringMVC+Spring+MyBatis，特点：速度快、性能高、配置简单，在互联网项目中广泛使用。SSM框架整合其实就是分别实现Spring与SpringMVC、Spring与MyBatis的整合，实现整合的主要工作就是把SpringMVC、MyBatis中的对象配置到Spring容器中，交给Spring来管理。2、系统架构设计1）数据存储：采用...
快速搭建SSM框架
o_wenhao的博客
06-04 274
1、主目录如图
ssm框架demo
11-07
一个ssm框架小demo，框架的包目录结构，包含登录，增删查改，分页，jsp文件放在WEN-INF下等的简单实现，有数据库文件，源代码，结果视频。
ssm框架原理分析
12-17
SSM 框架原理分析 SSM 框架是当前 Java Web 开发中最流行的框架之一，它是由 Spring、SpringMVC 和 MyBatis 三个框架组成的。下面我们将对 SSM 框架的三个原理进行分析。 一、Spring 框架原理 Spring 框架是 SSM ...
基于Java的SSM框架设计源码
最新发布
04-07
本项目是一个基于Java语言开发的SSM框架，包含64个文件，主要文件类型包括Java源代码、XML配置文件、HTML页面、JavaScript脚本、CSS样式表、Git忽略文件、Markdown文档、SQL数据库文件、EOT字体文件和SVG图片。...
SSM框架项目实例
03-09
一个SSM框架整合的小系统，叫做在线考试系统，简单来说就是实现教师（管理员）发布考试和学生（普通用户）参加考试的功能，当然其中还有一些稍显复杂的东西。 项目经反馈存在一些问题，如有需要，可加QQ群了解，有...
ssm用来分页的工具类
03-29
spring-sprifengmvc-mybatis中封装的一个分页工具类。方便以后使用，教程地址http://blog.csdn.net/chenyidong521/article/details/68094490
SSM框架介绍.pptx
11-30
Ssm框架介绍 Ssm框架是Java领域中的一种流行的框架，它是由Spring、SpringMVC和Mybatis三个组件组成的。下面我们将对Ssm框架的每个组件进行详细的介绍。 Spring框架介绍 Spring框架是Java应用最广的框架，它的...
ssm_SSM框架_
10-03
ssm框架示例，进行一个小小的训练训练训练训练
SSM框架例子
09-12
SSM框架例子源码下载，完整打包分享给大家哈，需要的可以下载学习！
SSM框架搭建视频教程
09-10
SSM框架搭建视频教程，包含Zookeeper实战课程，文件内含百度云下载链接，请自行下载观看，链接失效时可联系邮箱补发，谢谢，赶快下载吧！！
SSM框架简单整合教程
惊鸿的技术博客
05-11 293
文章目录底层创建数据库表导包项目图Mybatis框架Spring框架Spring-mvc框架 底层创建数据库表 使用mysql，在数据库mybatis中创建user表 CREATE TABLE `user` ( `uid` tinyint(2) NOT NULL, `uname` varchar(20) DEFAULT NULL, `usex` varchar(10) DEFAULT NULL, PRIMARY KEY (`uid`) )； 并向其中插入数据。 insert into u
SSM框架整合
weixin_46744534的博客
01-13 195
文章目录SSM框架整合整合思路前驱准备mybatis层整合spring层整合springmvc层整合每次需要手写的部分实际操作前驱部分mybatis层整合spring层整合springmvc层整合每次需要手写的部分难点辨析 SSM框架整合 整合思路 前驱准备 新建项目 检查是否含有web框架（没有添加上框架支持） 导入依赖和Maven资源过滤设置 建立基本结构和框架：java包（pojo、service、dao、controller、utils、filter文件夹）resources包（mapper文件夹
ssm整合框架
wanping0201的博客
10-21 424
前言：ssm整合框架就是将mybatis,spring,springMVC进行整合，得到一个完整的可迁移的项目框架，在以后的项目中可以按照这套框架进行开发。 在整合前创建一个数据库smbms,然后添加user表。 ssm整合步骤： 1.首先创建一个空白模板的maven项目，然后导入相应的jar包，主要的jar包，有 mysql驱动、c3p0连接池、mybatis、springmvc、spring-mybatis、spring-jdbc、aop、lombok <?xml version="1.0" e
ssm(springmvc4+spring4+mybatis3)整合实战-个人博客系统-util介绍与开发首页
青松之竹_Java博客
06-17 3611
ssm(springmvc4+spring4+mybatis3)整合实战-个人博客系统-util介绍与开发首页 下面把util工具类也分享出来吧，util弄好之后，就可以启动项目到tomcat7试试，如果没问题，就说明ssm框架的整合已经成功一大半了。 包package com.steadyjack.util，建立下面各个工具类用于后期各个组件使用。 Crypto...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值