ego项目注意的点

最新推荐文章于 2022-04-27 15:16:25 发布

WALL-E/

最新推荐文章于 2022-04-27 15:16:25 发布

阅读量490

点赞数

本文链接：https://blog.csdn.net/liar_____/article/details/107479665

版权

1.@transactional

对于数据库的增删改操作需要在方法上面添加注解@transactional，增删改成功返回1否则返回0。如果throws的是Exception而不是DaoException则需要写成@transactional（rollbackFor = Exception.class）

2.项目结构

在这里插入图片描述

3.逆向工程

，mybatis generration,
insert和insertselective,第一个必须每个属性都要有值，第二个可以不用有值。
selectByExample和 selectByExampleWithBLOBS，后面一个可以吧数据库中的text数据也查出来，查询全部就要把条件设置为null。

4.Restful

：

@RequestMapping("/rest/item/query/item/desc/{id}")
    @ResponseBody
    public EgoResult showTbItemDesc(@PathVariable long id){
        return tbItemDescService.selectTbItemDescById(id);
    }

5.json格式

，{}大括号代表的json Object类型，jdk中为object，[]小括号代表的是json Array 在jdk中表现为List

6.Application.class

…Application.class 不要放在同级目录下，如下：
在这里插入图片描述
如果放在了com.ego.potal的包下，其他项目的com.ego.sender等包下的类，启动类不会加载到

7.需要配置类的API：

redis,cache,SpringSecurity,RabbitMQSender

package com.ego.portal.config;

import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

@Configuration
public class CacheConfig {
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        //缓存配置对象
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();

        redisCacheConfiguration = redisCacheConfiguration.entryTtl(Duration.ofMinutes(30L)) //设置缓存的默认超时时间：30分钟
                .disableCachingNullValues()             //如果是空值，不缓存
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))         //设置key序列化器
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));  //设置value序列化器

        return RedisCacheManager
                .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                .cacheDefaults(redisCacheConfiguration).build();
    }
}

package com.ego.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    //使用BCrypt算法加密
    @Bean
    protected PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //form表单登录验证
        http.formLogin()
                .loginProcessingUrl("/login")  //处理登录post请求接口，无需自己实现
                .successForwardUrl("/loginSuccess")  //登录成功转发接口
                .loginPage("/");  未登录跳转页面,设置了authenticationentrypoint后无需设置未登录跳转

        //谁可以访问什么
        http.authorizeRequests()
                .antMatchers("/","/css/**","/js/**").permitAll() //都可以访问（静态资源）
                .anyRequest().authenticated(); //除上面的其他的所有http请求都要验证

        //关闭打开的csrf保护
        http.csrf().disable();

        // deny禁止iframe调用
        http.headers().frameOptions().disable();
    }
}

package com.ego.sender.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class SenderConfig {
    @Value("${ego.rabbitmq.content.queueName}")
    private String contentQueue;

    /**
     * 如果没有队列，帮助创建队列。
     *
     * @return
     */
    @Bean
    public Queue queue() {
        return new Queue(contentQueue);
    }

    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange("amq.direct");
    }

    @Bean
    // 参数名和方法名一直就是从spring容器中获取对应方法的返回值,将队列和交换器绑定在一起
    public Binding binding(Queue queue, DirectExchange directExchange){
        return BindingBuilder.bind(queue).to(directExchange).withQueueName();
    }
}

8.需要在yml中配置的

#Nginx地址
ego:
  fastdfs:
    nginx: http://192.168.8.129:8888/

#静态变量
  bigad:
    categoryid: 89
  rabbitmq:
    content:
      queueName: content
#dubbo配置
dubbo:
  application:
    name: ego-manager
  registry:
    address: zookeeper://192.168.8.128:2181
#tomcat端口
server:
  port: 8081

#视图解析器
spring:
  mvc:
    view:
      prefix: /WEB-INF/jsp/
      suffix: .jsp
      #扫描其他的application-*.yml
        profiles:
    active: commons,redis
#RabbitMQ
spring:
  rabbitmq:
    host: 192.168.8.132
    username: root
    password: root
#redis
spring:
  redis:
    host: 192.168.8.130

9.HTTPClient使用

因为HTTPClient是同步请求，所以要交给RabbitMQ消息队列进行异步请求，
RabbitMQ最主要的就是两点：
1.可以实现异步请求，提高了性能。
2.可以实现消息队列，先进的先执行，排队功能
可以使其访问另外一个项目的控制器，完成控制器所完成的内容

//调用的代码块
HttpClientUtil.doGet("http://localhost:8082/bigad");

/**
	 * 被调用的控制器
     * 更新大广告到redis，被rabbitMQ_receive的HTTPClient调用
     * @return
     */
    @RequestMapping("/bigad")
    @ResponseBody
    public String RedisAddBigAd(){
        tbContentService.showBig2();
        System.out.println("Controller");
        return "ok";
    }

10.各工具的启动

redis:./redis-server redis-conf
solr: ./solr start -force
rabbitMQ:
./rabbitmq-server -detached
FastDFS：
service fdfs_storge start
service fdfs_tra start
nginx: ./nginx
zookeeper: ./zkServer.sh start

11.redis

redis 没有修改，对其新增操作就包括修改，

12.solr

solr没有修改，只能删除和新增

13.类的变量

如果定义的类的变量，方法中引用时都要去新建一个，例如

//应该直接在方法中创建一个变量，这样：
String key = cartRedisKey+tbUser.getId();
//不应该直接更改类的变量，因为如果别的方法再次调用，有可能会显示你这个方法更改之后的值，不再是原先的值了，
cartRedisKey = cartRedisKey+tbUser.getId();



//另外，如果定义一个获取不到值的变量，则不会给内存地址，即：
List<CartPojo> cartPojoList = (List<CartPojo>) redisTemplate.opsForValue().get(cartKey);
//如果上面的redisTemplate没有获取到到值，则为null，并且不会给cartPojoList分配内存地址，
//就不能够使用cartPojoList.add()函数
//改为如下代码：
List<CartPojo> cartPojoList = new ArrayList<>();
cartPojoList = (List<CartPojo>) redisTemplate.opsForValue().get(cartKey);


//在List和Map中循环遍历，不需要再将值重新放入到Map或者list中，因为他已经自动更改了，例如：
//而且Map和List更改的都是一开始声明的变量，而不是Map自己创建的，即是这些变量储存的内存地址，
//当更改时，更改的都是原先的变量的值
public class Test {
    public static void main(String[] args) {
        Map<Integer,TbUser> map = new HashMap<>();
        System.out.println(map.toString()==null);
        System.out.println(map.size()==0);
        TbUser tbUser1 = new TbUser();
        tbUser1.setId(1l);
        TbUser tbUser2 = new TbUser();
        tbUser2.setId(2l);
        TbUser tbUser3 = new TbUser();
        tbUser3.setId(3l);
        map.put(1,tbUser1);
        map.put(2,tbUser2);
        map.put(3,tbUser3);
        for (Integer key :
                map.keySet()) {
            if (key.equals(2)){
            	//在中间进行map中变量的更改是可以的，并且不必再次放入到Map中
                map.get(key).setId(100l);
            }
        }
        for (Integer key :
                map.keySet()) {
            System.out.println("map循环遍历"+map.get(key).getId());
        }

        List<TbUser> list = new ArrayList<>();
        list.add(tbUser1);
        list.add(tbUser2);
        list.add(tbUser3);
        for (TbUser tu :
                list) {
                //List也是可以突然更改，并不用再次取出放入等操作
            if (tu.getId()==3L){
                tu.setId(300L);
            }
        }

        for (TbUser tu :
                list) {
            System.out.println("List循环"+tu.getId());
        }
//原先的值已经更改，代表之前的操作是对原有变量的操作
        System.out.println(tbUser1.getId());
        System.out.println(tbUser2.getId());
        System.out.println(tbUser3.getId());

    }
}


public class TbUser {
    private Long id;

    @Override
    public String toString() {
        return "TbUser{" +
                "id=" + id +
                '}';
    }

    public TbUser() {
    }

    public TbUser(Long id) {
        this.id = id;
    }

    public Long getId() {
        return id;
    }

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

14.RabbitMQ

如果不是传递类，则直接可以变量接收
如果把类当做参数进行RabbitMQ传递，要将被传递的类进行序列化，

public class OrderPojo implements Serializable {
public static final long serialVersionUID=1L;

同时，如果在Receive中接收这个参数数据，需要进行反序列化，并且接收参数代表是同步消息。不再异步，但是队列特点还在，可以处理高并发

public void orderCreate(Message msg) {
 byte[] body = msg.getBody();
InputStream is = new ByteArrayInputStream(body);
ObjectInputStream objectInputStream = null;
 objectInputStream = new ObjectInputStream(is);
OrderPojo orderPojo = (OrderPojo) objectInputStream.readObject();
}

15.自己创建并使用Exception

1.自己创建exception并进行抛出

public class DaoException extends RuntimeException{
    public DaoException(String message) {
        super(message);
    }
}

//方法中返回参数直接，方法名抛出，注意事务回滚
throws DaoException
throw new DaoException("更改商品和商品描述信息失败");




 @Override
    //声明式事务注解，监听到异常会事务回滚，注意这个注解！！
    @Transactional
    public int updateTbItemByIds(long[] ids, int status) throws DaoException{
        int index = 0;
        for (long id :
                ids) {
            TbItem tbItem = new TbItem();
            tbItem.setId(id);
            tbItem.setStatus((byte) status);
            tbItem.setUpdated(new Date());
            index+=tbItemMapper.updateByPrimaryKeySelective(tbItem);
        }
        if (index == ids.length){
            return 1;
        }
        throw new DaoException("批量更改商品状态失败");
    }

16.请求头与接收参数

 @RequestMapping("/cart/order-cart.html")
    //请求参数是:?id=159575547860068&id=159575388563078
    public String showOrderCart(@RequestParam List<Long> id,Model model){

  @RequestMapping("/cart/deleteByIds")
    @ResponseBody
    //请求参数是：?id=159598520930496&ids=159575547860068,159575388563078
    public int deleteCartByIds(Long userId,Long[] ids){

17.项目中所有的文件都没有了，只有文件夹了

提交git错误，commit中应该可以恢复，之后每个项目都要保存一下，或者及时提交到github中，可以在github中更新！！！！

18.重新回顾注意

1.要注意配置类放行静态资源
2.CacheRedis储存到redis中数据会出现乱码判断结果时忽略乱码
内容即可。这是因为默认对 Redis 的 value 序列化器使用 JdkSerializationRedisSerializer 序列化器。
更换序列化器后同时也会解决 redis 中数据前面出现乱码的问题。
下面整个代码的目的：把 redis 的 value 序列化器修改为
GenericJackson2JsonRedisSerializer，就支持返回值为对象或集合了。
3.springboot访问不到资源，修改MODULE_WORKING_DIR$
4.BeanUtils.copyProperties(被复制对象, 粘贴内容的对象);

WALL-E/

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ego项目注意的点

1.对于数据库的增删改操作需要在方法上面添加注解@transactional，增删改成功返回1否则返回0。如果throws的是Exception而不是DaoException则需要写成@transactional（rollbackFor = Exception.class）2.项目结构3.逆向工程，mybatis generration,insert和insertselective,第一个必须每个属性都要有值，第二个可以不用有值。selectByExample和 selectByExampleWi
复制链接

扫一扫