springboot整合框架(二)

springboot整合mybatis(xml配置方式)

 <!-- springboot整合mybatis -->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.1</version>
	    </dependency>
	    
<!-- MySQL -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>
		
<!-- alibaba的druid数据库连接池 -->
		 <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.11</version>
        </dependency>
        
 <!-- 分页插件 -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.1.2</version>
        </dependency>
        
<!-- @Param注解在该包中 -->
	    <dependency>
		    <groupId>org.apache.ibatis</groupId>
		    <artifactId>ibatis-core</artifactId>
		    <version>3.0</version>
		</dependency>

application.yml

#数据源配置：
spring:
    datasource:
        name: test
        url: jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf-8
        username: root
        password: root
        type: com.alibaba.druid.pool.DruidDataSource
        driver-class-name: com.mysql.jdbc.Driver
        filters: stat
        maxActive: 20
        initialSize: 1
        maxWait: 60000
        minIdle: 1
        timeBetweenEvictionRunsMillis: 60000
        minEvictableIdleTimeMillis: 300000
        validationQuery: select 'x'
        testWhileIdle: true
        testOnBorrow: false
        testOnReturn: false
        poolPreparedStatements: true
        maxOpenPreparedStatements: 20
#Mybatis的配置
mybatis:
  #"*.xml"表示扫描"mapper"目录下的所有以".xml"结尾的文件
  mapper-locations: classpath:mapper/*.xml
  #配置别名
  #type-aliases-package: com.yunxiang.pojo
  config-location: classpath:mybatis/SqlMapConfig.xml
#PageHelper分页插件
 pagehelper:
   helperDialect: mysql
   reasonable: true
   supportMethodsArguments: true
   params: count=countSql

注：使用".yml"格式的全局配置文件时，各配置的第一个关键字必须顶格写(“spring:”、“mybatis:”、" pagehelper:“)；并且赋值时”："后面必须有一个空格。

SqlMapConfig.xml

#Mybatis配置文件:
<?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>

注：springboot整合mybatis(xml配置方式)时，"mapper.xml"文件需要放置在"src/main/resources"路径下，“mapper.java"要放置在"src/main/java"路径下，并且在springboot的启动类中要使用”@MapperScan(“com.yunxiang.mapper”)“注解来扫描"mapper.java”。

springboot整合mybatis(注解方式)

		<!-- springboot整合mybatis,注解版 -->
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.1</version>
	    </dependency>
	   
		<!-- MySQL -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>

application.properties

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.url=jdbc:mysql://localhost:3306/test?characterEncoding=utf-8

UserMapper.java

import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import com.yunxiang.pojo.User;


public interface UserMapper {
   
	@Select("select * from user where name = #{name}")
	User findUserByName(@Param("name") String name);
	
	@Insert("insert into user(name, sex,address,brithday) values(#{user.name},#{user.sex},#{user.address},#{user.brithday})")
	void addUser(@Param("user")User name);
}

User.java

import java.util.Date;

public class User {
    private Integer id;

    private String name;

    private Date brithday;

    private String sex;

    private String address;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    public Date getBrithday() {
        return brithday;
    }

    public void setBrithday(Date brithday) {
        this.brithday = brithday;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex == null ? null : sex.trim();
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address == null ? null : address.trim();
    }
}

UserService .java

public interface UserService {
	
	User findUserByname(String name);
	
	void addUser(User user);

}

UserServiceImpl.java

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.yunxiang.mapper.UserMapper;
import com.yunxiang.pojo.User;
import com.yunxiang.service.UserService;

@Service
public class UserServiceImpl implements UserService {

	@Autowired
	private UserMapper userMapper;
	
	@Override
	public User findUserByname(String name) {
		User user = userMapper.findUserByName(name);
		return user;
	}

	@Override
	public void addUser(User user) {
		userMapper.addUser(user);
	}

}

UserController.java

import java.util.Date;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.yunxiang.pojo.User;
import com.yunxiang.service.UserService;

@Controller
public class UserController {
	
	@Autowired
	private UserService userService;
	
	@RequestMapping("/findUser/{name}")
	@ResponseBody
	public User findUserByName(@PathVariable String name){
		
		User user = userService.findUserByname(name);
		return user;
	}
	
	@RequestMapping("/addUser")
	@ResponseBody
	public String addUser(){
		User user = new User();
		user.setName("小花");
		user.setSex("男");
		user.setBrithday(new Date());
		user.setAddress("河南信阳");
		userService.addUser(user);
		return "success";
	}
}

SpringApplications.java

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication(scanBasePackages="com.yunxiang")
@MapperScan("com.yunxiang.mapper")
public class SpringApplications {
	
	public static void main(String[] args) {
		SpringApplication.run(SpringApplications.class, args);
	}
}

注：springboot整合mybatis，使用注解方式方式时，可以不需要mappe.xml文件，可以在接口中直接使用"@Select"、“@Insert”、“@Update”、“@Delete"标签在对应的抽象方法上直接写出对应的SQL语句即可。同时在springboot的启动类中要使用”@MapperScan(“com.yunxiang.mapper”)“注解来扫描"mapper.java”。

springboot区分多数据源

在springboot中，如果当项目需要使用不同的数据库时，可以通过配置文件的方式来区分多数据源的目的。
application.properties

#SpringBoot整合多数据源
spring.datasource.test.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.test.username=root
spring.datasource.test.password=root
spring.datasource.test.url=jdbc:mysql://localhost:3306/test?characterEncoding=utf-8

spring.datasource.taotao.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.taotao.username=root
spring.datasource.taotao.password=root
spring.datasource.taotao.url=jdbc:mysql://localhost:3306/taotao?characterEncoding=utf-8

注：因为springboot默认配置中没有"spring.datasource.test.driver-class-name"等属性，所有必须自己将各个数据库注入当springboot容器中。
注册数据库信息

import javax.sql.DataSource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

//注册到Spring容器中
//指明当前类是通过配置文件
@Configuration
/*
 * 指明该数据库接口的扫描包,
 * 接口就写在"com.yunxiang.test.mapper"中
 */
@MapperScan(basePackages="com.yunxiang.test.mapper",sqlSessionFactoryRef="testSqlSessionFactory")
/*
 * 因为要配置多个数据库信息，在加载时，容器不知道加载另一个，
 * 使用@Primary注解修修饰的那个接口实现类可以默认优先选择
 */
 
@Primary
public class DataSource1 {
	
	//private DataSource1(){}

	
    @Bean(name="testDatasource")
    //获取数据库信息
    @ConfigurationProperties(prefix="spring.datasource.test")
    @Primary
    public DataSource testDatasource() {
        return DataSourceBuilder.create().build();
    }
    /**
     * 创建SqlSessionFactory
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name="testSqlSessionFactory")
    @Primary
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("testDatasource")DataSource dataSource) 
            throws Exception {
        SqlSessionFactoryBean bean=new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }
    /**
     * 配置事务管理
     */
    @Bean(name="testTransactionManager")
    @Primary
    public DataSourceTransactionManager testTransactionManager(
            @Qualifier("testDatasource")DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
 
    @Bean(name="testSqlSessionTemplate")
    @Primary
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("testSqlSessionFactory")
    SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

import javax.sql.DataSource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

@Configuration
@MapperScan(basePackages="com.yunxiang.taotao.mapper",sqlSessionFactoryRef="taotaoSqlSessionFactory")
public class DataSource2 {

	/**
     * 配置taotao数据库
     * @return
     */
    @Bean(name="taotaoDatasource")
    @ConfigurationProperties(prefix="spring.datasource.taotao")
    public DataSource testDatasource() {
        return DataSourceBuilder.create().build();
    }
    /**
     * 创建SqlSessionFactory
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name="taotaoSqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("taotaoDatasource")DataSource dataSource) 
            throws Exception {
        SqlSessionFactoryBean bean=new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        //如果还有分页等其他事务
//      bean.setMapperLocations(new PathMatchingResourcePatternResolver().
//              getResources("classpath:mybatis/test1/*.xml"));
        return bean.getObject();
    }
    /**
     * 配置事务管理
     */
    @Bean(name="taotaoTransactionManager")
    public DataSourceTransactionManager testTransactionManager(
            @Qualifier("taotaoDatasource")DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
 
    @Bean(name="taotaoSqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("taotaoSqlSessionFactory")
    SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

注：在配置好全局配置信息和定义好数据库信息后，其他的就和别的一样。

springboot中的事务管理

在springboot中，默认配置好了事务，当某个方法需要使用事务控制时，只需要在该方法上使用"@Transactional"注解，也可以在当前类上使用"@Transactional"注解。当在方法上使用"@Transactional"注解时，表示只有该方法才会支持事务控制；当在方法上使用"@Transactional"注解时，表示该类的所有方法都支持事务控制。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.yunxiang.mapper.UserMapper;
import com.yunxiang.pojo.User;
import com.yunxiang.service.UserService;

@Service
public class UserServiceImpl implements UserService {

	@Autowired
	private UserMapper userMapper;
	
	@Override
	public User findUserByname(String name) {
		User user = userMapper.findUserByName(name);
		return user;
	}
	//添加事务控制
	@Transactional
	@Override
	public void addUser(User user) {
		userMapper.addUser(user);
		int i = 1 / 0;

	}

}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.yunxiang.mapper.UserMapper;
import com.yunxiang.pojo.User;
import com.yunxiang.service.UserService;

@Service
@Transactional
public class UserServiceImpl implements UserService {

	@Autowired
	private UserMapper userMapper;
	
	@Override
	public User findUserByname(String name) {
		User user = userMapper.findUserByName(name);
		return user;
	}

	
	@Override
	public void addUser(User user) {
		userMapper.addUser(user);
		int i = 1 / 0;

	}

}

springboot整合JPA-Hibernate

pom

<!-- springboot整合jpa -->
      <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-data-jpa</artifactId>
      </dependency>
      <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
       </dependency>

application.properties

#让控制器输出json字符串格式
spring.datasource.test.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.test.username=root
spring.jackson.serialization.indent-output=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

创建实体类

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name="t_user")
public class User {

	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private Integer id;

	@Column(name="username")
    private String name;

    private Date brithday;

    private String sex;

    private String address;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public Date getBrithday() {
		return brithday;
	}

	public void setBrithday(Date brithday) {
		this.brithday = brithday;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public String getAddress() {
		return address;
	}

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

注：“@Entity"注解，表示springboot会在数据库中创建一种数据表，如果没有使用”@Table(name=“t_user”)“注解来命名，就以实体类的类名为数据表的表名。”@Id"注解表示指明该属性值为主键；“@GeneratedValue"注解表示主键的生成策略。”@Column(name=“username”)"注解表示指明数据表中的字段名，如果不写此参数，则字段名为属性名。
UserDao

import org.springframework.data.jpa.repository.JpaRepository;

import com.yunxiang.pojo.User;

public interface UserDao extends JpaRepository<User, Integer> {

}

注：使用jpa时，dao成只写接口，并且所有的接口对象都有继承"JpaRepository"类，该类中定义了jpa操作数据库的一些方法。
启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@SpringBootApplication(scanBasePackages="com.yunxiang")
//扫描实体类
@EntityScan("com.yunxiang.pojo")
//扫描dao层
@EnableJpaRepositories("com.yunxiang.dao")
public class SpringApplications {
	
	public static void main(String[] args) {
		SpringApplication.run(SpringApplications.class, args);
	}

}

注：在springboot整合JPA-Hibernate中，可以根据pojo对象类直接在数据库中创建数据表，并且在启动类中使用"@EntityScan(“com.yunxiang.pojo”)"注解来扫描pojo对象，使用@EnableJpaRepositories(“com.yunxiang.dao”)注解来扫描dao层。别的层的操作都一致。

springboot整合Email

pom

<!-- 邮件依赖 -->
     <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-mail</artifactId>
     </dependency>

application.properties

#JavaMailSender 邮件发送的配置
#如果使用163邮箱 ，修改成smtp.163.com，
spring.mail.host=smtp.qq.com
spring.mail.username=183434043@qq.com
spring.mail.password=ahexjedcxzyybhfe
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true
spring.mail.properties.mail.smtp.starttls.required=true
#若使用QQ邮箱发送邮件，则需要修改为spring.mail.host=smtp.qq.com，同时spring.mail.password改为QQ邮箱的授权码。
#QQ邮箱->设置->账户->POP3/SMTP服务:开启服务后会获得QQ的授权码 

EmailConfig.java

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

//指明该类是一个配置文件
@Component
public class EmailConfig {

	//定义发件人
	@Value("${spring.mail.username}")
	private String emailfrom;

	public String getEmailfrom() {
		return emailfrom;
	}

	public void setEmailfrom(String emailfrom) {
		this.emailfrom = emailfrom;
	}
	
}

EmailService.java

import java.io.File;

public interface EmailService {

	//发送简单的邮件，只含有文本的邮件
	public void sendSimpleEmail(String sendTo,String title,String content);

	//发送带有附件的邮件
	public boolean sendAttachmentEmail(String sendTo,String title,String content, String filePath);
}

EmailServiceImpl.java

import java.io.File;

import javax.mail.internet.MimeMessage;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.FileSystemResource;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Service;

import com.yunxiang.email.EmailConfig;
import com.yunxiang.service.EmailService;

@Service
public class EmailServiceImpl implements EmailService {

	@Autowired
	private EmailConfig emailConfig;
	
	@Autowired
	private JavaMailSender emailSender;
	
	@Override
	public void sendSimpleEmail(String sendTo, String title, String content) {
		//简单邮件的方式
		SimpleMailMessage message = new SimpleMailMessage();
		//发送人
		message.setFrom(emailConfig.getEmailfrom());;

		//接收人
		message.setTo(sendTo);
		//发送的主题
		message.setSubject(title);
		//发送的内容
		message.setText(content);
		
		//发送
		emailSender.send(message);
		
		
	}
	@Override
	public boolean sendAttachmentEmail(String sendTo, String title, String content,String filePath) {
		
		File file = new File(filePath);
		boolean flag = file.exists();
		if(flag){
			String fileName = file.getName();
			MimeMessage  msg = emailSender.createMimeMessage();
			try {
				
				MimeMessageHelper helper = new MimeMessageHelper(msg,true);
			
				helper.setFrom(emailConfig.getEmailfrom());
				helper.setTo(sendTo);
				helper.setSubject(title);
				helper.setText(content);
				FileSystemResource r = new FileSystemResource(file);
				/**
				 * 参数1：文件的全名称必须指明文件的后缀，
				 *       如果不指明文件的后缀，则文件会打不开；
				 * 参数2：文件信息。
				 */
				helper.addAttachment(fileName, r);
				emailSender.send(msg);
				
			} catch (Exception e) {
				e.printStackTrace();
			}
			
		}
		return flag;
		
	}
}

EmailController.java

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;

import com.yunxiang.service.EmailService;

@Controller
public class EmailController {

	@Autowired
	private EmailService  emailService;
	
	@RequestMapping("/simple")
	@ResponseBody
	public String sendSimpleEmail(){
		String sendTo = "19837679510@163.com";
		String title = "工作";
		String content = "加油";
		emailService.sendSimpleEmail(sendTo, title, content);
		return "邮件发送成功";
	}
	
	@RequestMapping("/attach")
	@ResponseBody
	public String sendAttachmentEmail(){
		String sendTo = "18839420996@163.com";
		String title = "work";
		String content = "加油";
		String filePath = "c://测试//名单.xlsx";
		emailService.sendAttachmentEmail(sendTo, title, content, filePath);
		return "邮件发送成功";
	}
}