Spring Boot学习随笔1

最新推荐文章于 2022-10-04 21:26:29 发布

zt999129

最新推荐文章于 2022-10-04 21:26:29 发布

阅读量181

点赞数

文章标签： spring boot

本文链接：https://blog.csdn.net/zt999129/article/details/109104372

版权

@Component("userManager")
public class UserManagerImpl implements UserManager {
	
	}

在持久层、业务层和控制层分别采用 @Repository、@Service 和 @Controller 对分层中的类进行凝视，而用 @Component 对那些比較中立的类进行凝视
这里就是说把这个类交给Spring管理，又一次起个名字叫userManager，因为不好说这个类属于哪个层面。就用@Component**

@Component
public class User {
    @Value("1")
    private int id;
    @Value("zhangtao")
    private String name;
}
``

2.“execution( *全限定类名 (…)) ”定义任意方法的执行

 @Pointcut("execution(* com.example.demo.service.UserServiceImpl.printUser(..))")

3**.基于注解的aop开发步骤**：
<1.创建目标接口和目标类。
<2.创建切面类
❤️.将目标类和切面类的对象创建权交给Spring.(即在实现类和切面类上都加上@Component("")注解).
<4.在切面类中使用注解配置织入关系（在切面类上加@Aspect注解,并在通知前加@Before,@After等注解）
<5.在pom.xml文件中添加相关依赖

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>2.3.0.RELEASE</version>
        </dependency>

示例代码:
接口：

package nuc.stu.anno.yy;

public interface TargetInterface {
    public void save();
}

实现类：

package nuc.stu.anno.yy;

import org.springframework.stereotype.Component;

@Component("target")
public class Target implements TargetInterface{
    @Override
    public void save() {
        System.out.println("save running....");
    }
}

切面类:

package nuc.stu.anno.yy;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.aop.aspectj.MethodInvocationProceedingJoinPoint;
import org.springframework.stereotype.Component;
@Aspect
@Component("myAspect")
public class MyAspect {
    @Before("execution(* nuc.stu.anno.yy.Target.save(..))")
    public void before(){
        System.out.println("前置增强");
    }

    @AfterReturning("execution(* nuc.stu.anno.yy.Target.save(..))")
    public void afterRunning(){
        System.out.println("后置增强");
    }
    @Around("execution(* nuc.stu.anno.yy.Target.save(..))")
    public Object around(ProceedingJoinPoint pjp)throws Throwable{
        System.out.println("环绕前置增强");
        Object proceed = pjp.proceed();
        System.out.println("环绕后置增强");
        return proceed;
    }
    @AfterThrowing("execution(* nuc.stu.anno.yy.Target.save(..))")
    public void afterThrowing(){
        System.out.println("异常抛出增强");
    }
    @After("execution(* nuc.stu.anno.yy.Target.save(..))")
    public void after(){
        System.out.println("最终增强");
    }
}

最后创建一个控制层

package nuc.stu.anno.yy.controller;

import nuc.stu.anno.yy.MyAspect;
import nuc.stu.anno.yy.Target;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;


@Controller
public class controler {
    @Autowired
    Target target;
    @RequestMapping("/printt")
    @ResponseBody
    public void printt(){
       // System.out.println("这里运行了。。。");
        target.save();
    }
}

接下来运行，并在浏览器中输入：localhost:8080/printt

4.@RestController是@ResponseBody和@Controller的组合注解
5.Springloc容器初始化：
第一:将Ioc容器中所有的bean实例化为对象（即相当于new一个对象）
第二:将各个bean依赖的属性值注入进去（即属性赋值）

MapperRegistry:注册绑定我们的Mapper文件；
方式一：（推荐使用）

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

方式二：使用class文件注册绑定

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

注意：在使用class文件注册绑定时需要注意以下两点：
1.接口和他的Mapper配置文件必须同名
2.接口和他的Mapper配置文件必须在同一个包下

在这里插入图片描述

Log4j

1.先导入Log4j的包

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

2.log4j.properties

### set log levels ###
log4j.rootLogger = DEBUG,Console,File

###  输出到控制台  ###
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.Target=System.out
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern= %d{ABSOLUTE} %5p %c{1}:%L - %m%n


### 输出到日志文件 ###
log4j.appender.File=org.apache.log4j.RollingFileAppender 
log4j.appender.File.File=./logs/kuang.log
log4j.appender.File.MaxFileSize=10MB
log4j.appender.File.Threshold=DEBUG
log4j.appender.File.layout=org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern=[%p][%d{yyyy-MM-dd HH\:mm\:ss,SSS}][%c]%m%n

3.配置log4j为日志实现

<settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>

log4j简单使用：
1.在要使用Log4j的类中，导入import org.apache.log4j.Logger;
2.日志对象，参数为当前的class

static Logger logger = Logger.getLogger(UserDaoTest.class);

3日志级别：

logger.info("info:进入testLog4j");
        logger.debug("debug:进入testLog4j");
        logger.error("error:进入testLog4j");

11.23

@Data           自动构造get,set方法
@AllArgsConstructor        全参构造函数
@NoArgsConstructor       无参构造函数

复杂查询环境的搭建

测试环境搭建
1.导入lombok
2.新建实体类，Teacher,Student.
3.新建Mapper接口
4.在resources中建立Mapper.XML文件
5.在核心配置文件中绑定我们的Mapper接口或者文件
6.测试查询是否能够成功。

重载，从简单说，就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者重载方法。在Java中同一个类中的2个或2个以上的方法可以有同一个名字，只要它们的参数声明不同即可。这种情况下，该方法就被称为重载，这个过程称为方法重载；

以后就可以通过IDutils.getId来获取随机id；

public class IDutils {
    public static String getId(){
        return UUID.randomUUID().toString().replaceAll("-","");
    }

    @Test
    public void test(){
        System.out.println(IDutils.getId());
        System.out.println(IDutils.getId());
        System.out.println(IDutils.getId());
    }
}

在这里插入图片描述
BlogMapper:

package com.kuang.dao;
import com.kuang.entity.Blog;
import java.util.List;
import java.util.Map;
public interface BlogMapper {
    int addBlog(Blog blog);
    List<Blog> queryBlogIF(Map map);
}

BlogMapper.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">
<!--configuration核心配置文件-->
<mapper namespace="com.kuang.dao.BlogMapper">

    <insert id="addBlog" parameterType="com.kuang.entity.Blog">
        insert into mybatis.blog(id,title,author,create_time,views)values(#{id},#{title},#{author},#{createTime},#{views})
    </insert>

    <select id="queryBlogIF" parameterType="map" resultType="com.kuang.entity.Blog">
        select * from mybatis.blog where 1=1
        <if test="title != null">                                   /*动态SQL*/
            and title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </select>
</mapper>

Blog:

package com.kuang.entity;
import lombok.Data;
import java.util.Date;

@Data
public class Blog {
    private String id;
    private String title;
    private String author;
    private Date createTime;   //属性名与字段名不一致
    private int views;
}

MybatisUtils:

package com.kuang.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;

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static{
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //既然有了SqlSessionFactory,顾名思义，我们就可以从中获取SqlSession的实例了。
    //SqlSession完全包含了面向数据库执行SQL命令所需的所有方法
    public static SqlSession getsqlSession(){
     return sqlSessionFactory.openSession(true);
    }
}

IDutils:

package com.kuang.utils;
import org.junit.Test;
import java.util.UUID;
@SuppressWarnings("all") //抑制警告
public class IDutils {
    public static String getId(){
        return UUID.randomUUID().toString().replaceAll("-","");
    }
 /*UUID.randomUUID().toString();//用来生成数据库的主键id*/
    @Test
    public void test(){
        System.out.println(IDutils.getId());
        System.out.println(IDutils.getId());
        System.out.println(IDutils.getId());
    }
}



//以后就可以通过IDutils.getId来获取随机id；

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核心配置文件-->
<configuration>

    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>    <!--自动驼峰命名规则映射-->
    </settings>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>  <!--事务管理-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper class="com.kuang.dao.BlogMapper"/>
    </mappers>
</configuration>

Mytest:

package com.kuang.dao;

import com.kuang.entity.Blog;
import com.kuang.utils.IDutils;
import com.kuang.utils.MybatisUtils;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.Date;
import java.util.HashMap;
import java.util.List;

public class Mytest {
    @Test
    public void addIntiBolg(){
        SqlSession sqlSession = MybatisUtils.getsqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        Blog blog = new Blog();

        blog.setId(IDutils.getId());
        blog.setTitle("Mybatis如此简单");
        blog.setAuthor("狂神说");
        blog.setCreateTime(new Date());
        blog.setViews(9999);
        mapper.addBlog(blog);

        blog.setId(IDutils.getId());
        blog.setTitle("java如此简单");
        blog.setAuthor("狂神说");
        blog.setCreateTime(new Date());
        blog.setViews(8888);
        mapper.addBlog(blog);

        blog.setId(IDutils.getId());
        blog.setTitle("Spring如此简单");
        blog.setAuthor("狂神说");
        blog.setCreateTime(new Date());
        blog.setViews(7896);
        mapper.addBlog(blog);
        sqlSession.close();
    }

    @Test
    public void queryBlogIF(){
        SqlSession sqlSession = MybatisUtils.getsqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
        HashMap map = new HashMap();
        //map.put("title","Mybatis如此简单");
        map.put("author","狂神说");
        List<Blog> blogs = mapper.queryBlogIF(map);
        for (Blog blog : blogs) {
            System.out.println(blog);
        }
    }
}

addIntiBolg运行后，查看数据库，截图如下:

在这里插入图片描述
queryBlogIF运行后的截图:
:map.put(“author”,“狂神说”); ---------查询author为“狂神说”的博客

@Repository

@Repository和@Controller、@Service、@Component的作用差不多，都是把对象交给spring管理。@Repository用在持久层的接口上，这个注解是将接口的一个实现类交给spring管理。

@Autowired

@Autowired 是一个注释，它可以对类成员变量、方法及构造函数进行标注，让 spring 完成 bean 自动装配的工作。

static{}中的代码优先加载；

zt999129

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring Boot学习随笔1

@Component("userManager")public class UserManagerImpl implements UserManager { }在持久层、业务层和控制层分别采用 @Repository、@Service 和 @Controller 对分层中的类进行凝视，而用 @Component 对那些比較中立的类进行凝视这里就是说把这个类交给Spring管理，又一次起个名字叫userManager，因为不好说这个类属于哪个层面。就用@Component**@Compone
复制链接

扫一扫